coding-friend-cli 1.0.0

package/dist/init-ONRXFOZ5.js

@@ -0,0 +1,431 @@
+import {
+  DEFAULT_CONFIG
+} from "./chunk-HRVSKMNA.js";
+import {
+  ensureShellCompletion,
+  hasShellCompletion
+} from "./chunk-VHZQ6KEU.js";
+import {
+  run
+} from "./chunk-6CGGT2FD.js";
+import {
+  claudeSettingsPath,
+  globalConfigPath,
+  localConfigPath,
+  resolvePath
+} from "./chunk-AQXTNLQD.js";
+import {
+  log
+} from "./chunk-6DUFTBTO.js";
+import {
+  mergeJson,
+  readJson
+} from "./chunk-IUTXHCP7.js";
+
+// src/commands/init.ts
+import { checkbox, confirm, input, select } from "@inquirer/prompts";
+import { appendFileSync, existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+function isGitRepo() {
+  return run("git", ["rev-parse", "--is-inside-work-tree"]) === "true";
+}
+function checkDocsFolders() {
+  const folders = ["docs/plans", "docs/memory", "docs/research", "docs/learn"];
+  return folders.every((f) => existsSync(f));
+}
+function checkGitignore() {
+  if (!existsSync(".gitignore")) return false;
+  return readFileSync(".gitignore", "utf-8").includes("# coding-friend");
+}
+function checkLanguage() {
+  const local = readJson(localConfigPath());
+  const global = readJson(globalConfigPath());
+  return !!(local?.language || global?.language);
+}
+function checkLearnConfig() {
+  const local = readJson(localConfigPath());
+  const global = readJson(globalConfigPath());
+  return !!(local?.learn || global?.learn);
+}
+function getResolvedOutputDir() {
+  const local = readJson(localConfigPath());
+  if (local?.learn?.outputDir) return resolvePath(local.learn.outputDir);
+  const global = readJson(globalConfigPath());
+  if (global?.learn?.outputDir) return resolvePath(global.learn.outputDir);
+  return null;
+}
+function isExternalOutputDir(outputDir) {
+  if (!outputDir) return false;
+  const cwd = process.cwd();
+  return !outputDir.startsWith(cwd);
+}
+function checkClaudePermissions(outputDir) {
+  const settings = readJson(claudeSettingsPath());
+  if (!settings) return false;
+  const permissions = settings.permissions;
+  if (!permissions?.allow) return false;
+  const homePath = outputDir.replace(homedir(), "~");
+  return permissions.allow.some(
+    (rule) => rule.includes(outputDir) || rule.includes(homePath)
+  );
+}
+async function setupDocsFolders() {
+  const folders = ["docs/plans", "docs/memory", "docs/research", "docs/learn"];
+  const created = [];
+  for (const f of folders) {
+    if (!existsSync(f)) {
+      run("mkdir", ["-p", f]);
+      created.push(f);
+    }
+  }
+  if (created.length > 0) {
+    log.success(`Created: ${created.join(", ")}`);
+  } else {
+    log.dim("All docs folders already exist.");
+  }
+}
+async function setupGitignore() {
+  const choice = await select({
+    message: "Add coding-friend artifacts to .gitignore?",
+    choices: [
+      { name: "Yes, ignore all", value: "all" },
+      { name: "Partial \u2014 pick which to ignore", value: "partial" },
+      { name: "No \u2014 keep everything tracked", value: "none" }
+    ]
+  });
+  if (choice === "none") {
+    log.dim("Skipped .gitignore config.");
+    return;
+  }
+  const allEntries = [
+    "docs/plans/",
+    "docs/memory/",
+    "docs/research/",
+    "docs/learn/",
+    ".coding-friend/"
+  ];
+  let entries = allEntries;
+  if (choice === "partial") {
+    entries = await checkbox({
+      message: "Which folders to ignore?",
+      choices: allEntries.map((e) => ({ name: e, value: e }))
+    });
+    if (entries.length === 0) {
+      log.dim("Nothing selected.");
+      return;
+    }
+  }
+  const existing = existsSync(".gitignore") ? readFileSync(".gitignore", "utf-8") : "";
+  const newEntries = entries.filter((e) => !existing.includes(e));
+  if (newEntries.length === 0) {
+    log.dim("All entries already in .gitignore.");
+    return;
+  }
+  const block = `
+# coding-friend
+${newEntries.join("\n")}
+`;
+  appendFileSync(".gitignore", block);
+  log.success(`Added to .gitignore: ${newEntries.join(", ")}`);
+}
+async function setupLanguage() {
+  const choice = await select({
+    message: "What language should generated docs be written in?",
+    choices: [
+      { name: "English", value: "en" },
+      { name: "Vietnamese", value: "vi" },
+      { name: "Other", value: "_other" }
+    ]
+  });
+  if (choice === "_other") {
+    const lang = await input({ message: "Enter language name:" });
+    return lang || "en";
+  }
+  return choice;
+}
+async function setupLearnConfig(gitAvailable = true) {
+  const locationChoice = await select({
+    message: "Where to store learning docs?",
+    choices: [
+      { name: "In this project (docs/learn/)", value: "local" },
+      { name: "A separate folder", value: "external" }
+    ]
+  });
+  let outputDir = "docs/learn";
+  let isExternal = false;
+  if (locationChoice === "external") {
+    outputDir = await input({
+      message: "Enter path (absolute or ~/...):",
+      validate: (val) => val.length > 0 ? true : "Path cannot be empty"
+    });
+    isExternal = true;
+    const resolved = resolvePath(outputDir);
+    if (!existsSync(resolved)) {
+      const create = await confirm({
+        message: `Folder ${resolved} doesn't exist. Create it?`,
+        default: true
+      });
+      if (create) {
+        run("mkdir", ["-p", resolved]);
+        log.success(`Created ${resolved}`);
+      }
+    }
+  }
+  const catChoice = await select({
+    message: "Categories for organizing learning docs?",
+    choices: [
+      {
+        name: "Use defaults (concepts, patterns, languages, tools, debugging)",
+        value: "defaults"
+      },
+      { name: "Customize", value: "custom" }
+    ]
+  });
+  let categories = DEFAULT_CONFIG.learn.categories;
+  if (catChoice === "custom") {
+    console.log('Enter categories (format: "name: description"). Empty line to finish.');
+    const customCats = [];
+    let keepGoing = true;
+    while (keepGoing) {
+      const line = await input({
+        message: `Category ${customCats.length + 1}:`
+      });
+      if (!line) {
+        keepGoing = false;
+      } else {
+        const [name, ...descParts] = line.split(":");
+        customCats.push({
+          name: name.trim(),
+          description: descParts.join(":").trim() || name.trim()
+        });
+      }
+    }
+    if (customCats.length > 0) categories = customCats;
+  }
+  let autoCommit = false;
+  if (isExternal && gitAvailable) {
+    autoCommit = await confirm({
+      message: "Auto-commit learning docs to git after each /cf-learn?",
+      default: false
+    });
+  }
+  const indexChoice = await select({
+    message: "How should learning docs be indexed?",
+    choices: [
+      { name: "No index", value: "none" },
+      { name: "Single README at root", value: "single" },
+      { name: "Per-category READMEs", value: "per-category" }
+    ]
+  });
+  let readmeIndex = false;
+  if (indexChoice === "single") readmeIndex = true;
+  else if (indexChoice === "per-category") readmeIndex = "per-category";
+  return { outputDir, categories, autoCommit, readmeIndex, isExternal };
+}
+async function setupClaudePermissions(outputDir, autoCommit) {
+  const resolved = resolvePath(outputDir);
+  const homePath = resolved.startsWith(homedir()) ? resolved.replace(homedir(), "~") : resolved;
+  const rules = [
+    `Read(${homePath}/**)`,
+    `Edit(${homePath}/**)`,
+    `Write(${homePath}/**)`
+  ];
+  if (autoCommit) {
+    rules.push(`Bash(cd ${homePath} && git add:*)`);
+    rules.push(`Bash(cd ${homePath} && git commit:*)`);
+  }
+  const settingsPath = claudeSettingsPath();
+  const settings = readJson(settingsPath);
+  if (!settings) {
+    log.warn(
+      "~/.claude/settings.json not found. Create it via Claude Code settings first."
+    );
+    return;
+  }
+  const permissions = settings.permissions ?? {};
+  const existing = permissions.allow ?? [];
+  const missing = rules.filter(
+    (r) => !existing.some((e) => e === r || e.includes(homePath))
+  );
+  if (missing.length === 0) {
+    log.dim("All permission rules already configured.");
+    return;
+  }
+  console.log("\nTo avoid repeated permission prompts, add these rules:");
+  for (const r of missing) {
+    console.log(`  ${r}`);
+  }
+  const ok = await confirm({
+    message: "Add these to ~/.claude/settings.json?",
+    default: true
+  });
+  if (!ok) {
+    log.dim("Skipped. You'll get prompted each time.");
+    return;
+  }
+  permissions.allow = [...existing, ...missing];
+  settings.permissions = permissions;
+  const { readJson: _r, writeJson: _w, ...restImports } = await import("./json-2XS56OJY.js");
+  _w(settingsPath, settings);
+  log.success(`Added ${missing.length} permission rules.`);
+}
+function isDefaultConfig(config) {
+  if (config.language && config.language !== "en") return false;
+  if (config.learn) {
+    const l = config.learn;
+    if (l.outputDir && l.outputDir !== "docs/learn") return false;
+    if (l.autoCommit) return false;
+    if (l.readmeIndex) return false;
+    if (l.categories) {
+      const defaultNames = DEFAULT_CONFIG.learn.categories.map((c) => c.name);
+      const configNames = l.categories.map((c) => c.name);
+      if (JSON.stringify(defaultNames) !== JSON.stringify(configNames))
+        return false;
+    }
+  }
+  return true;
+}
+async function saveConfig(config) {
+  if (isDefaultConfig(config)) {
+    log.dim(
+      "All settings match defaults \u2014 no config file needed."
+    );
+    return;
+  }
+  const target = await select({
+    message: "Save settings as global or project-only?",
+    choices: [
+      { name: "Global (all projects)", value: "global" },
+      { name: "This project only", value: "local" },
+      { name: "Both", value: "both" }
+    ]
+  });
+  if (target === "global" || target === "both") {
+    mergeJson(globalConfigPath(), config);
+    log.success(`Saved to ${globalConfigPath()}`);
+  }
+  if (target === "local" || target === "both") {
+    mergeJson(localConfigPath(), config);
+    log.success(`Saved to ${localConfigPath()}`);
+  }
+}
+async function initCommand() {
+  console.log("=== \u{1F33F} Coding Friend Init \u{1F33F} ===");
+  console.log();
+  const gitAvailable = isGitRepo();
+  if (!gitAvailable) {
+    log.warn("Not inside a git repo \u2014 git-related steps will be skipped.");
+    console.log();
+  }
+  const resolvedOutputDir = getResolvedOutputDir();
+  const hasExternalDir = checkLearnConfig() && isExternalOutputDir(resolvedOutputDir);
+  const steps = [
+    { name: "docs", label: "Create docs folders", done: checkDocsFolders() },
+    ...gitAvailable ? [{ name: "gitignore", label: "Configure .gitignore", done: checkGitignore() }] : [],
+    { name: "language", label: "Set docs language", done: checkLanguage() },
+    { name: "learn", label: "Configure /cf-learn", done: checkLearnConfig() },
+    { name: "completion", label: "Setup shell tab completion", done: hasShellCompletion() }
+  ];
+  if (hasExternalDir && resolvedOutputDir) {
+    steps.push({
+      name: "permissions",
+      label: "Configure Claude permissions",
+      done: checkClaudePermissions(resolvedOutputDir)
+    });
+  }
+  console.log("coding-friend setup status:");
+  for (const step of steps) {
+    const status = step.done ? "\x1B[32m[done]\x1B[0m" : "\x1B[33m[pending]\x1B[0m";
+    console.log(`  ${status} ${step.label}`);
+  }
+  console.log();
+  const pending = steps.filter((s) => !s.done);
+  if (pending.length === 0) {
+    log.success("Everything is already configured!");
+    return;
+  }
+  const action = await select({
+    message: `${pending.length} pending step(s). What do you want to do?`,
+    choices: [
+      { name: "Apply all pending", value: "all" },
+      { name: "Pick which to apply", value: "pick" },
+      { name: "Cancel", value: "cancel" }
+    ]
+  });
+  if (action === "cancel") {
+    log.dim("Cancelled.");
+    return;
+  }
+  let selected = pending;
+  if (action === "pick") {
+    const picked = await checkbox({
+      message: "Which steps to apply?",
+      choices: pending.map((s) => ({ name: s.label, value: s.name }))
+    });
+    selected = pending.filter((s) => picked.includes(s.name));
+    if (selected.length === 0) {
+      log.dim("Nothing selected.");
+      return;
+    }
+  }
+  const config = {};
+  let learnOutputDir = "docs/learn";
+  let learnAutoCommit = false;
+  let isExternal = false;
+  for (const step of selected) {
+    console.log();
+    log.step(step.label);
+    switch (step.name) {
+      case "docs":
+        await setupDocsFolders();
+        break;
+      case "gitignore":
+        await setupGitignore();
+        break;
+      case "language": {
+        const lang = await setupLanguage();
+        config.language = lang;
+        break;
+      }
+      case "learn": {
+        const learn = await setupLearnConfig(gitAvailable);
+        config.learn = {
+          outputDir: learn.outputDir,
+          categories: learn.categories,
+          autoCommit: learn.autoCommit,
+          readmeIndex: learn.readmeIndex
+        };
+        learnOutputDir = learn.outputDir;
+        learnAutoCommit = learn.autoCommit;
+        isExternal = learn.isExternal;
+        break;
+      }
+      case "completion":
+        ensureShellCompletion();
+        break;
+      case "permissions":
+        if (resolvedOutputDir) {
+          await setupClaudePermissions(
+            resolvedOutputDir,
+            learnAutoCommit
+          );
+        }
+        break;
+    }
+  }
+  if (isExternal && !selected.some((s) => s.name === "permissions") && !checkClaudePermissions(resolvePath(learnOutputDir))) {
+    console.log();
+    log.step("Configure Claude permissions");
+    await setupClaudePermissions(learnOutputDir, learnAutoCommit);
+  }
+  if (Object.keys(config).length > 0) {
+    console.log();
+    await saveConfig(config);
+  }
+  console.log();
+  log.success("Setup complete!");
+  log.dim("Available commands: /cf-plan, /cf-commit, /cf-review, /cf-learn");
+}
+export {
+  initCommand
+};

package/dist/json-2XS56OJY.js

@@ -0,0 +1,10 @@
+import {
+  mergeJson,
+  readJson,
+  writeJson
+} from "./chunk-IUTXHCP7.js";
+export {
+  mergeJson,
+  readJson,
+  writeJson
+};

package/dist/mcp-LMMIFH4B.js

@@ -0,0 +1,104 @@
+import {
+  getLibPath,
+  resolveDocsDir
+} from "./chunk-KZT4AFDW.js";
+import "./chunk-HRVSKMNA.js";
+import {
+  run
+} from "./chunk-6CGGT2FD.js";
+import "./chunk-AQXTNLQD.js";
+import {
+  log
+} from "./chunk-6DUFTBTO.js";
+import "./chunk-IUTXHCP7.js";
+
+// src/commands/mcp.ts
+import { existsSync, readdirSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+function countMdFiles(dir) {
+  let count = 0;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      count += countMdFiles(join(dir, entry.name));
+    } else if (entry.name.endsWith(".md") && entry.name !== "README.md") {
+      count++;
+    }
+  }
+  return count;
+}
+async function mcpCommand(path) {
+  const docsDir = resolveDocsDir(path);
+  const mcpDir = getLibPath("learn-mcp");
+  if (!existsSync(docsDir)) {
+    log.error(`Docs folder not found: ${docsDir}`);
+    log.dim("Run /cf-learn first to generate some docs.");
+    process.exit(1);
+  }
+  const docCount = countMdFiles(docsDir);
+  if (docCount === 0) {
+    log.error(`No .md files found in ${docsDir}`);
+    log.dim("Run /cf-learn first to generate some docs.");
+    process.exit(1);
+  }
+  console.log("=== \u{1F33F} Coding Friend MCP \u{1F33F} ===");
+  log.info(`Docs folder: ${chalk.cyan(docsDir)}`);
+  log.info(`Found: ${chalk.green(docCount)} docs`);
+  console.log();
+  if (!existsSync(join(mcpDir, "node_modules"))) {
+    log.step("Installing MCP server dependencies (one-time setup)...");
+    const result = run("npm", ["install", "--silent"], { cwd: mcpDir });
+    if (result === null) {
+      log.error("Failed to install dependencies");
+      process.exit(1);
+    }
+    log.success("Done.");
+  }
+  if (!existsSync(join(mcpDir, "dist"))) {
+    log.step("Building MCP server...");
+    const result = run("npm", ["run", "build", "--silent"], { cwd: mcpDir });
+    if (result === null) {
+      log.error("Failed to build MCP server");
+      process.exit(1);
+    }
+    log.success("Done.");
+  }
+  console.log();
+  const serverPath = join(mcpDir, "dist", "index.js");
+  console.log(`Add this to your MCP client config:
+
+--- Claude Desktop / Claude Chat (claude_desktop_config.json) ---
+
+{
+  "mcpServers": {
+    "coding-friend-learn": {
+      "command": "node",
+      "args": ["${serverPath}", "${docsDir}"]
+    }
+  }
+}
+
+--- Generic MCP client ---
+
+Server command: node ${serverPath} ${docsDir}
+Transport: stdio
+
+--- Available tools ---
+
+Read:
+  list-categories    List all categories with doc counts
+  list-docs          List docs, filter by category/tag
+  read-doc           Read full content of a doc
+  search-docs        Full-text search across all docs
+  get-review-list    Docs that need review
+
+Write:
+  create-doc         Create new learning doc
+  update-doc         Append content or update tags
+  improve-doc        Get improvement suggestions
+  track-knowledge    Record understanding level (remembered/needs-review/new)
+`);
+}
+export {
+  mcpCommand
+};

package/dist/postinstall.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/postinstall.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import {
+  ensureShellCompletion
+} from "./chunk-VHZQ6KEU.js";
+import "./chunk-6DUFTBTO.js";
+
+// src/postinstall.ts
+ensureShellCompletion();

package/dist/statusline-7D6YU5YM.js

@@ -0,0 +1,64 @@
+import {
+  claudeSettingsPath,
+  pluginCachePath
+} from "./chunk-AQXTNLQD.js";
+import {
+  log
+} from "./chunk-6DUFTBTO.js";
+import {
+  readJson,
+  writeJson
+} from "./chunk-IUTXHCP7.js";
+
+// src/commands/statusline.ts
+import { existsSync, readdirSync } from "fs";
+import { confirm } from "@inquirer/prompts";
+import chalk from "chalk";
+function findLatestVersion(cachePath) {
+  if (!existsSync(cachePath)) return null;
+  const versions = readdirSync(cachePath, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort().reverse();
+  return versions[0] ?? null;
+}
+async function statuslineCommand() {
+  console.log("=== \u{1F33F} Coding Friend Statusline \u{1F33F} ===");
+  console.log();
+  const cachePath = pluginCachePath();
+  const version = findLatestVersion(cachePath);
+  if (!version) {
+    log.error(
+      "coding-friend plugin not found in cache. Install it first via Claude Code."
+    );
+    return;
+  }
+  const hookPath = `${cachePath}/${version}/hooks/statusline.sh`;
+  if (!existsSync(hookPath)) {
+    log.error(`Statusline hook not found: ${hookPath}`);
+    return;
+  }
+  log.info(`Found plugin ${chalk.green(`v${version}`)}`);
+  const settingsPath = claudeSettingsPath();
+  const settings = readJson(settingsPath) ?? {};
+  const existing = settings.statusLine;
+  if (existing?.command) {
+    log.warn(`Statusline already configured: ${existing.command}`);
+    const overwrite = await confirm({
+      message: "Overwrite existing statusline config?",
+      default: true
+    });
+    if (!overwrite) {
+      log.dim("Skipped.");
+      return;
+    }
+  }
+  settings.statusLine = {
+    type: "command",
+    command: `bash ${hookPath}`
+  };
+  writeJson(settingsPath, settings);
+  log.success("Statusline configured!");
+  log.dim("Restart Claude Code (or start a new session) to see it.");
+  log.dim("Shows: plugin name, active model, and git branch.");
+}
+export {
+  statuslineCommand
+};