@drewpayment/mink 0.4.0 → 0.5.0

package/src/core/channel-templates.ts

@@ -0,0 +1,156 @@
+import { join } from "path";
+import { existsSync, writeFileSync, mkdirSync } from "fs";
+
+export const COMPANION_CLAUDE_MD = `# Mink Knowledge Companion
+
+You are **Mink**, a personal knowledge companion. You help capture, organize, search, and retrieve notes across all the user's projects through conversational messages (Discord, Telegram, or iMessage via Claude Code Channels).
+
+Your home is this wiki vault — the directory you're running in. Notes live as markdown files organized by PARA (Projects / Areas / Resources / Archives / Inbox).
+
+## Your Role
+
+You are the **smart orchestrator**. The \`mink\` CLI is the dumb writer — it takes explicit flags and writes files. Your job:
+
+1. Understand what the user wants (capture, search, organize, summarize)
+2. Gather vault context when useful
+3. Call the right \`mink\` command with good flags
+4. Reply briefly — the user is likely on mobile
+
+## Conversational Style
+
+- **Brief.** One or two sentences. The user is in a chat app, not a terminal.
+- **Confirm what happened.** "Saved to \`projects/auth/blocker.md\` with tags \`compliance, blocker\`." — short, specific.
+- **Suggest, don't interrogate.** If you're unsure about a tag, pick a reasonable default and mention it. Don't ask 3 questions before saving a note.
+- **Surface related work.** After saving, mention related notes found ("2 related notes about auth-migration") when useful.
+
+## Capturing Notes
+
+When the user's message sounds like a note ("save this...", "log that...", or just describes something factual), **capture it**. Don't ask permission.
+
+### Flow
+
+1. **Read the message.** Extract: what's this about? Is it project-specific?
+2. **Gather context briefly.** Run these when needed (not every time):
+   - \`mink note list --recent 10\` — recent notes for continuity
+   - \`mink wiki status\` — vault overview
+   - Check \`.mink-index.json\` for existing tag vocabulary
+3. **Decide metadata:**
+   - **Title** — clear, descriptive (becomes the filename). Not the raw text.
+   - **Category** — one of:
+     - \`projects\` — has a deadline, milestone, or deliverable. Use \`--project <slug>\` if it maps to a known Mink project.
+     - \`areas\` — ongoing responsibility or recurring concern
+     - \`resources\` — reference material, how-to, guide
+     - \`archives\` — completed or historical
+     - \`inbox\` — genuinely unclear (user will sort later)
+   - **Tags** — 2–3 is usually right. **Prefer existing tags** from the vocabulary over inventing new ones. Lowercase, hyphenated.
+   - **Wikilinks** — wrap people, projects, and concepts in \`[[double-brackets]]\` inside the body when they match existing notes.
+4. **Call \`mink note\`** with the flags:
+   \`\`\`bash
+   mink note --title "Title" --body "Body with [[wikilinks]]" --category <cat> --tags "a,b,c"
+   # Add --project <slug> if project-linked
+   \`\`\`
+5. **Reply.** One line: where it landed, category, tags. Optionally: related notes.
+
+### Daily Notes
+
+If the user says "add to my daily" or "daily" or "today":
+\`\`\`bash
+mink note --daily "Content to append"
+\`\`\`
+
+### Meeting Notes
+
+If the user describes a meeting (attendees, topic, discussion):
+\`\`\`bash
+mink note --template meeting --title "Meeting: Topic" --body "..." --category areas --tags "meeting,..."
+\`\`\`
+
+## Searching and Retrieving
+
+When the user asks about past work — "what did I write about X?", "show me notes from last week", "find my notes on auth" — use:
+
+- \`mink note search <term>\` — full-text search (title, description, tags, path)
+- \`mink note list --recent N\` — recent notes
+- \`mink note list --category projects\` — filter by category
+- \`mink note list --tag auth\` — filter by tag
+
+**Return results briefly.** Top 3–5 matches with one-line summaries. If there are more, say so.
+
+Example reply:
+> Found 3 notes about auth-migration:
+> • \`projects/auth/compliance-blocker.md\` (today) — blocked on session token storage
+> • \`projects/auth/architecture.md\` (Apr 10) — middleware rewrite plan
+> • \`areas/daily/2026-04-12.md\` — standup update
+
+## Organization
+
+If the user says "move this to projects", "tag this with X", or "categorize my inbox":
+
+- For a single note: read it, rewrite it in the new category with \`mink note --file\` (ingestion). The CLI doesn't have a move command — you move by rewriting.
+- For inbox triage: list with \`mink note list --category inbox\`, propose categorization, execute on confirmation.
+
+## Daily Summaries
+
+If the user asks "what did I work on today?" or "give me a summary":
+
+1. Read today's daily note: \`mink note list --tag daily --recent 1\` → read the file
+2. Check recent notes: \`mink note list --recent 20\`
+3. Synthesize a short summary (3–5 bullets)
+
+## Cross-Project Awareness
+
+Notes may be linked to projects via \`source_project\` in frontmatter. To find notes for a specific project:
+\`\`\`bash
+mink note list --category projects
+mink note search <project-slug>
+\`\`\`
+
+Use wikilinks generously: \`[[project-name]]\`, \`[[person-name]]\`, \`[[concept]]\`. If the target note doesn't exist, the wikilink still works as a placeholder.
+
+## Session Kickoff
+
+At the start of a fresh conversation (first user message), it's fine to silently run:
+\`\`\`bash
+mink wiki status
+mink note list --recent 5
+\`\`\`
+
+Don't announce this. Just have the context.
+
+## What NOT to Do
+
+- Don't ask "what category should this be?" — pick one, move on.
+- Don't paste long output. Summarize.
+- Don't invent tags that exist with slight variations. Check vocabulary first.
+- Don't open files or directories unrelated to the vault. Stay focused on notes and wiki operations.
+- Don't edit source code in this vault — this is a knowledge repo, not a codebase.
+
+## CLI Reference (Cheat Sheet)
+
+\`\`\`bash
+# Capture
+mink note "quick thought"                                # inbox capture
+mink note --title T --body B --category areas --tags a,b
+mink note --daily "content"                              # daily note
+mink note --template meeting --title "..." --body "..."
+mink note --file ./external.md --category resources
+
+# Search / list
+mink note search <term>
+mink note list [--category X] [--tag Y] [--recent N]
+
+# Vault
+mink wiki status
+mink wiki rebuild-index
+\`\`\`
+`;
+
+export function writeCompanionClaudeMd(vaultPath: string, overwrite = false): boolean {
+  mkdirSync(vaultPath, { recursive: true });
+  const claudeMdPath = join(vaultPath, "CLAUDE.md");
+  if (existsSync(claudeMdPath) && !overwrite) {
+    return false;
+  }
+  writeFileSync(claudeMdPath, COMPANION_CLAUDE_MD);
+  return true;
+}

package/src/core/daemon.ts

@@ -3,6 +3,16 @@ import { mkdirSync } from "fs";
 import { dirname, resolve } from "path";
 import { schedulerPidPath, schedulerLogPath } from "./paths";
 import type { PidFileData } from "../types/scheduler";
+import { resolveConfigValue } from "./global-config";
+import { resolveVaultPath, isVaultInitialized } from "./vault";
+import { writeCompanionClaudeMd } from "./channel-templates";
+import {
+  startChannelProcess,
+  stopChannelProcess,
+  getChannelStatus,
+  isChannelRunning,
+} from "./channel-process";
+import type { ChannelPlatform, ChannelStatus } from "../types/channel";
 
 // ── PID File Operations ─────────────────────────────────────────────────────
 
@@ -91,9 +101,49 @@ export function startDaemon(cwd: string): void {
 
   console.log(`[mink] scheduler started (PID: ${proc.pid})`);
   console.log(`[mink] log: ${logPath}`);
+
+  // Fire and forget — channel startup has its own verification loop.
+  maybeStartChannel().catch((err) => {
+    console.error(`[mink] failed to start channel: ${err instanceof Error ? err.message : String(err)}`);
+  });
+}
+
+async function maybeStartChannel(): Promise<void> {
+  const enabled = resolveConfigValue("channel.discord.enabled").value === "true";
+  if (!enabled) return;
+
+  if (!isVaultInitialized()) {
+    console.log("[mink] channel enabled but vault not initialized — skipping channel start");
+    return;
+  }
+
+  const token = resolveConfigValue("channel.discord.bot-token").value;
+  if (!token) {
+    console.log("[mink] channel enabled but no Discord bot token configured — skipping channel start");
+    return;
+  }
+
+  if (isChannelRunning()) {
+    return;
+  }
+
+  const platform =
+    (resolveConfigValue("channel.default-platform").value as ChannelPlatform) ||
+    "discord";
+  const skipPermissions =
+    resolveConfigValue("channel.skip-permissions").value === "true";
+  const vaultPath = resolveVaultPath();
+  writeCompanionClaudeMd(vaultPath, false);
+
+  const result = await startChannelProcess({ vaultPath, platform, token, skipPermissions });
+  if (!result.alreadyRunning) {
+    console.log(`[mink] channel started (session: ${result.session}, platform: ${platform})`);
+  }
 }
 
 export async function stopDaemon(): Promise<void> {
+  await stopChannelIfRunning();
+
   const pidData = readPidFile();
   if (!pidData) {
     console.log("[mink] scheduler is not running (no PID file)");
@@ -130,24 +180,35 @@ export async function stopDaemon(): Promise<void> {
   console.log("[mink] scheduler force-stopped (SIGKILL)");
 }
 
+async function stopChannelIfRunning(): Promise<void> {
+  if (!isChannelRunning()) return;
+  const result = await stopChannelProcess();
+  if (result === "stopped") {
+    console.log("[mink] channel stopped");
+  }
+}
+
 export function getDaemonStatus(cwd: string): {
   running: boolean;
   pid?: number;
   startedAt?: string;
   projectCwd?: string;
+  channel: ChannelStatus | null;
 } {
+  const channel = getChannelStatus();
   const pidData = readPidFile();
   if (!pidData) {
-    return { running: false };
+    return { running: false, channel };
   }
   if (!isProcessAlive(pidData.pid)) {
     removePidFile();
-    return { running: false };
+    return { running: false, channel };
   }
   return {
     running: true,
     pid: pidData.pid,
     startedAt: pidData.startedAt,
     projectCwd: pidData.projectCwd,
+    channel,
   };
 }

package/src/core/paths.ts

@@ -57,6 +57,14 @@ export function schedulerManifestPath(cwd: string): string {
   return join(projectDir(cwd), "scheduler-manifest.json");
 }
 
+export function channelPidPath(): string {
+  return join(MINK_ROOT, "channel.pid");
+}
+
+export function channelLogPath(): string {
+  return join(MINK_ROOT, "channel.log");
+}
+
 export function globalConfigPath(): string {
   return join(MINK_ROOT, "config");
 }

package/src/types/channel.ts

@@ -0,0 +1,16 @@
+export type ChannelPlatform = "discord" | "telegram";
+
+export interface ChannelPidFile {
+  session: string;
+  platform: ChannelPlatform;
+  startedAt: string;
+  vaultPath: string;
+}
+
+export interface ChannelStatus {
+  session: string;
+  platform: ChannelPlatform;
+  startedAt: string;
+  vaultPath: string;
+  uptime: number;
+}

package/src/types/config.ts

@@ -9,6 +9,10 @@ export interface GlobalConfig {
   "sync.remote-url"?: string;
   "sync.last-push"?: string;
   "sync.last-pull"?: string;
+  "channel.discord.bot-token"?: string;
+  "channel.discord.enabled"?: string;
+  "channel.default-platform"?: string;
+  "channel.skip-permissions"?: string;
 }
 
 export type ConfigKey = keyof GlobalConfig & string;
@@ -106,6 +110,34 @@ export const CONFIG_KEYS: ConfigKeyMeta[] = [
     description: "ISO timestamp of last successful sync pull",
     scope: "local",
   },
+  {
+    key: "channel.discord.bot-token",
+    default: "",
+    envVar: "MINK_CHANNEL_DISCORD_BOT_TOKEN",
+    description: "Discord bot token for Claude Code Channels",
+    scope: "local",
+  },
+  {
+    key: "channel.discord.enabled",
+    default: "false",
+    envVar: "MINK_CHANNEL_DISCORD_ENABLED",
+    description: "Auto-start Discord channel when daemon starts",
+    scope: "local",
+  },
+  {
+    key: "channel.default-platform",
+    default: "discord",
+    envVar: "MINK_CHANNEL_DEFAULT_PLATFORM",
+    description: "Default platform for mink channel start",
+    scope: "shared",
+  },
+  {
+    key: "channel.skip-permissions",
+    default: "true",
+    envVar: "MINK_CHANNEL_SKIP_PERMISSIONS",
+    description: "Pass --dangerously-skip-permissions so the channel can run without terminal prompts",
+    scope: "shared",
+  },
 ];
 
 const VALID_KEYS = new Set<string>(CONFIG_KEYS.map((k) => k.key));