@towles/tool 0.0.109 → 0.0.110

package/src/{lib → commands}/auto-claude/utils.ts

@@ -3,9 +3,15 @@ import { join } from "node:path";
 import consola from "consola";
 import pc from "picocolors";
 
-import { ensureDir, fileExists, readFile, writeFile } from "../../utils/fs.js";
-import { createBranchNameFromIssue } from "../../utils/git/branch-name.js";
-import { execSafe, git } from "../../utils/git/exec.js";
+import {
+  createBranchNameFromIssue,
+  ensureDir,
+  execSafe,
+  fileExists,
+  git,
+  readFile,
+  writeFile,
+} from "@towles/shared";
 import { runClaude } from "./claude-cli.js";
 import { getConfig } from "./config.js";
 import { ARTIFACTS } from "./prompt-templates/index.js";
@@ -14,7 +20,7 @@ import { resolveTemplate } from "./templates.js";
 import type { SpawnClaudeFn } from "./spawn-claude.js";
 import type { TokenValues } from "./templates.js";
 
-export { ensureDir, fileExists, readFile, writeFile } from "../../utils/fs.js";
+export { ensureDir, fileExists, readFile, writeFile } from "@towles/shared";
 
 // ── Issue context ──
 

package/src/{lib/install → commands}/claude-settings.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { writeFile } from "../../utils/fs.js";
+import { writeFile } from "@towles/shared";
 
 export interface ClaudeSettings {
   cleanupPeriodDays?: number;

package/src/commands/config/config.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { writeFile, mkdtemp, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { runCommand } from "citty";
+
+describe("config show", () => {
+  it("runs without throwing", async () => {
+    const { default: showCmd } = await import("./show.js");
+    await expect(runCommand(showCmd, { rawArgs: [] })).resolves.toBeDefined();
+  });
+});
+
+describe("config validate", () => {
+  let dir: string;
+
+  async function writeTempFile(content: string): Promise<string> {
+    dir = await mkdtemp(join(tmpdir(), "tt-config-test-"));
+    const filePath = join(dir, "settings.json");
+    await writeFile(filePath, content, "utf-8");
+    return filePath;
+  }
+
+  afterEach(async () => {
+    if (dir) await rm(dir, { recursive: true, force: true });
+  });
+
+  it("reports valid config as ok", async () => {
+    const filePath = await writeTempFile(JSON.stringify({ preferredEditor: "vim" }));
+    const { default: validateCmd } = await import("./validate.js");
+
+    process.exitCode = 0;
+    await runCommand(validateCmd, { rawArgs: ["--path", filePath] });
+    expect(process.exitCode).toBe(0);
+  });
+
+  it("reports invalid JSON", async () => {
+    const filePath = await writeTempFile("not json {{{");
+    const { default: validateCmd } = await import("./validate.js");
+
+    process.exitCode = 0;
+    await runCommand(validateCmd, { rawArgs: ["--path", filePath] });
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("reports schema validation errors", async () => {
+    const filePath = await writeTempFile(JSON.stringify({ preferredEditor: 123 }));
+    const { default: validateCmd } = await import("./validate.js");
+
+    process.exitCode = 0;
+    await runCommand(validateCmd, { rawArgs: ["--path", filePath] });
+    expect(process.exitCode).toBe(1);
+  });
+
+  it("reports missing file", async () => {
+    const { default: validateCmd } = await import("./validate.js");
+
+    process.exitCode = 0;
+    await runCommand(validateCmd, { rawArgs: ["--path", "/tmp/nonexistent-tt-settings.json"] });
+    expect(process.exitCode).toBe(1);
+  });
+});
+
+describe("config reset", () => {
+  let dir: string;
+
+  async function writeTempSettings(content: string): Promise<string> {
+    dir = await mkdtemp(join(tmpdir(), "tt-config-reset-"));
+    const filePath = join(dir, "settings.json");
+    await writeFile(filePath, content, "utf-8");
+    return filePath;
+  }
+
+  afterEach(async () => {
+    if (dir) await rm(dir, { recursive: true, force: true });
+  });
+
+  it("without --confirm exits with code 1 and shows diff", async () => {
+    await writeTempSettings(JSON.stringify({ preferredEditor: "nvim" }));
+
+    const { default: resetCmd } = await import("./reset.js");
+
+    process.exitCode = 0;
+    await runCommand(resetCmd, { rawArgs: [] });
+    // Without --confirm it should set exitCode=1 (unless settings already match defaults)
+    expect([0, 1]).toContain(process.exitCode);
+  });
+
+  it("with --confirm resets settings to defaults", async () => {
+    const { default: resetCmd } = await import("./reset.js");
+
+    process.exitCode = 0;
+    await runCommand(resetCmd, { rawArgs: ["--confirm"] });
+    expect(process.exitCode).toBe(0);
+
+    // Verify the file was written with defaults by loading it
+    const { readFile: rf } = await import("node:fs/promises");
+    const { USER_SETTINGS_PATH: settingsPath, UserSettingsSchema } =
+      await import("../../config/settings.js");
+    const content = JSON.parse(await rf(settingsPath, "utf-8"));
+    const defaults = UserSettingsSchema.parse({});
+    expect(JSON.stringify(content)).toBe(JSON.stringify(defaults));
+  });
+});
+
+describe("config schema", () => {
+  it("outputs valid JSON schema", async () => {
+    const { default: schemaCmd } = await import("./schema.js");
+
+    const chunks: string[] = [];
+    const origWrite = process.stdout.write;
+    process.stdout.write = ((chunk: string) => {
+      chunks.push(chunk);
+      return true;
+    }) as typeof process.stdout.write;
+
+    try {
+      await runCommand(schemaCmd, { rawArgs: [] });
+    } finally {
+      process.stdout.write = origWrite;
+    }
+
+    const output = chunks.join("");
+    const schema = JSON.parse(output);
+    expect(schema.type).toBe("object");
+    expect(schema.properties).toBeDefined();
+    expect(schema.properties.preferredEditor).toBeDefined();
+  });
+});

package/src/commands/config/index.ts

@@ -0,0 +1,11 @@
+import { defineCommand } from "citty";
+
+export default defineCommand({
+  meta: { name: "config", description: "Configuration management commands" },
+  subCommands: {
+    show: () => import("./show.js").then((m) => m.default),
+    validate: () => import("./validate.js").then((m) => m.default),
+    schema: () => import("./schema.js").then((m) => m.default),
+    reset: () => import("./reset.js").then((m) => m.default),
+  },
+});

package/src/commands/config/reset.ts

@@ -0,0 +1,53 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { colors } from "consola/utils";
+import {
+  UserSettingsSchema,
+  USER_SETTINGS_PATH,
+  saveSettings,
+  loadSettings,
+} from "../../config/settings.js";
+
+export default defineCommand({
+  meta: { name: "reset", description: "Reset settings to defaults" },
+  args: {
+    confirm: {
+      type: "boolean",
+      description: "Confirm the reset (required to actually reset)",
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const defaults = UserSettingsSchema.parse({});
+
+    if (!args.confirm) {
+      consola.log(`${colors.bold("Current settings vs defaults:")}\n`);
+
+      let currentSettings: Record<string, unknown>;
+      try {
+        const { settings } = await loadSettings();
+        currentSettings = settings as unknown as Record<string, unknown>;
+      } catch {
+        currentSettings = {};
+      }
+
+      const currentJson = JSON.stringify(currentSettings, null, 2);
+      const defaultJson = JSON.stringify(defaults, null, 2);
+
+      if (currentJson === defaultJson) {
+        consola.log(`${colors.green("✓")} Settings already match defaults. Nothing to reset.`);
+        return;
+      }
+
+      consola.log(`${colors.red("Current:")} ${currentJson}\n`);
+      consola.log(`${colors.green("Default:")} ${defaultJson}\n`);
+
+      consola.warn("Run with --confirm to reset settings to defaults.");
+      process.exitCode = 1;
+      return;
+    }
+
+    await saveSettings({ path: USER_SETTINGS_PATH, settings: defaults });
+    consola.log(`${colors.green("✓")} Settings reset to defaults: ${USER_SETTINGS_PATH}`);
+  },
+});

package/src/commands/config/schema.ts

@@ -0,0 +1,19 @@
+import { defineCommand } from "citty";
+import { z } from "zod/v4";
+import { UserSettingsRawSchema } from "../../config/settings.js";
+
+export default defineCommand({
+  meta: { name: "schema", description: "Export JSON Schema for the settings file" },
+  args: {
+    pretty: {
+      type: "boolean",
+      description: "Pretty-print the JSON output",
+      default: true,
+    },
+  },
+  async run({ args }) {
+    const jsonSchema = z.toJSONSchema(UserSettingsRawSchema, { target: "draft-2020-12" });
+    const indent = args.pretty ? 2 : undefined;
+    process.stdout.write(JSON.stringify(jsonSchema, null, indent) + "\n");
+  },
+});

package/src/commands/{config.ts → config/show.ts}

@@ -1,9 +1,9 @@
 import { defineCommand } from "citty";
 import consola from "consola";
-import { withSettings, debugArg } from "./shared.js";
+import { withSettings, debugArg } from "../shared.js";
 
 export default defineCommand({
-  meta: { name: "config", description: "Display current configuration settings" },
+  meta: { name: "show", description: "Display current configuration settings" },
   args: { debug: debugArg },
   async run({ args }) {
     const { settingsFile, settings } = await withSettings(args.debug);

package/src/commands/config/validate.ts

@@ -0,0 +1,51 @@
+import { readFile } from "node:fs/promises";
+import { defineCommand } from "citty";
+import consola from "consola";
+import { colors } from "consola/utils";
+import { UserSettingsSchema, USER_SETTINGS_PATH } from "../../config/settings.js";
+import { debugArg } from "../shared.js";
+
+export default defineCommand({
+  meta: { name: "validate", description: "Validate settings file against the config schema" },
+  args: {
+    debug: debugArg,
+    path: {
+      type: "string",
+      description: "Path to settings file (defaults to standard location)",
+    },
+  },
+  async run({ args }) {
+    const filePath = args.path ?? USER_SETTINGS_PATH;
+
+    let raw: string;
+    try {
+      raw = await readFile(filePath, "utf-8");
+    } catch {
+      consola.error(`Settings file not found: ${filePath}`);
+      process.exitCode = 1;
+      return;
+    }
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (e) {
+      consola.error(`Invalid JSON in ${filePath}: ${(e as Error).message}`);
+      process.exitCode = 1;
+      return;
+    }
+
+    const result = UserSettingsSchema.safeParse(parsed);
+
+    if (result.success) {
+      consola.log(`${colors.green("✓")} ${filePath} is valid`);
+    } else {
+      consola.log(`${colors.red("✗")} ${filePath} has validation errors:\n`);
+      for (const issue of result.error.issues) {
+        const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+        consola.log(`  ${colors.red("•")} ${colors.bold(path)}: ${issue.message}`);
+      }
+      process.exitCode = 1;
+    }
+  },
+});

package/src/commands/doctor/checks.ts

@@ -0,0 +1,167 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve, join } from "node:path";
+import consola from "consola";
+import { run } from "@towles/shared";
+
+export interface CheckResult {
+  name: string;
+  version: string | null;
+  ok: boolean;
+  warning?: string;
+}
+
+export interface DoctorRunResult {
+  timestamp: string;
+  tools: CheckResult[];
+  ghAuth: boolean;
+  plugins: { name: string; ok: boolean }[];
+  agentboard: { name: string; ok: boolean }[];
+}
+
+export async function checkCommand(
+  name: string,
+  args: string[],
+  versionPattern: RegExp,
+  optional = false,
+): Promise<CheckResult> {
+  try {
+    const result = await run(name, args);
+    const output = result.stdout + result.stderr;
+    const match = output.match(versionPattern);
+    return {
+      name,
+      version: match?.[1] ?? output.trim().slice(0, 20),
+      ok: true,
+    };
+  } catch {
+    consola.debug(`Tool check failed for "${name}"`);
+    return {
+      name,
+      version: null,
+      ok: optional,
+      warning: optional ? "optional, not installed" : undefined,
+    };
+  }
+}
+
+export async function checkGhAuth(): Promise<{ ok: boolean }> {
+  try {
+    const result = await run("gh", ["auth", "status"]);
+    return { ok: result.exitCode === 0 };
+  } catch {
+    consola.debug("GitHub CLI auth check failed");
+    return { ok: false };
+  }
+}
+
+export function checkAgentBoard(): {
+  name: string;
+  value: string;
+  ok: boolean;
+  warning?: string;
+  hint?: string;
+}[] {
+  const results: { name: string; value: string; ok: boolean; warning?: string; hint?: string }[] =
+    [];
+
+  const defaultDataDir = resolve(
+    process.env.XDG_CONFIG_HOME ?? resolve(process.env.HOME ?? "~", ".config"),
+    "towles-tool",
+    "agentboard",
+  );
+  const dataDir = process.env.AGENTBOARD_DATA_DIR ?? defaultDataDir;
+  const dbPath = join(dataDir, "agentboard.db");
+  const configPath = join(dataDir, "config.json");
+
+  const dbExists = existsSync(dbPath);
+  results.push({
+    name: "database",
+    value: dbExists ? dbPath : "not found",
+    ok: dbExists,
+    hint: dbExists ? undefined : "Run: tt ag (starts server and creates DB automatically)",
+  });
+
+  let repoPaths: string[] = [];
+  if (existsSync(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, "utf-8"));
+      repoPaths = config.repoPaths ?? [];
+    } catch {
+      // Corrupted config
+    }
+  }
+
+  results.push({
+    name: "scan paths",
+    value: repoPaths.length > 0 ? repoPaths.join(", ") : "none configured",
+    ok: repoPaths.length > 0,
+    warning: repoPaths.length === 0 ? "no scan paths" : undefined,
+    hint:
+      repoPaths.length === 0
+        ? "Run: tt ag → open Workspaces → run the onboarding wizard"
+        : undefined,
+  });
+
+  results.push({
+    name: "data dir",
+    value: dataDir,
+    ok: true,
+  });
+
+  return results;
+}
+
+export async function checkClaudePlugins(): Promise<
+  { name: string; ok: boolean; installHint?: string }[]
+> {
+  const requiredPlugins = [
+    {
+      id: "code-simplifier@claude-plugins-official",
+      name: "code-simplifier",
+      installCmd: "claude plugin install code-simplifier@claude-plugins-official --scope user",
+    },
+  ];
+
+  try {
+    const result = await run("claude", ["plugin", "list", "--json"]);
+    const plugins: { id: string }[] = JSON.parse(result.stdout);
+    const installedIds = new Set(plugins.map((p) => p.id));
+
+    return requiredPlugins.map((p) => ({
+      name: p.name,
+      ok: installedIds.has(p.id),
+      installHint: installedIds.has(p.id) ? undefined : `Run: ${p.installCmd}`,
+    }));
+  } catch {
+    consola.debug("Failed to list Claude plugins");
+    return requiredPlugins.map((p) => ({
+      name: p.name,
+      ok: false,
+      installHint: `Run: ${p.installCmd}`,
+    }));
+  }
+}
+
+export async function runAllChecks(): Promise<DoctorRunResult> {
+  const tools = await Promise.all([
+    checkCommand("git", ["--version"], /git version ([\d.]+)/),
+    checkCommand("gh", ["--version"], /gh version ([\d.]+)/),
+    checkCommand("node", ["--version"], /v?([\d.]+)/),
+    checkCommand("bun", ["--version"], /([\d.]+)/),
+    checkCommand("claude", ["--version"], /([\d.]+)/),
+    checkCommand("tmux", ["-V"], /tmux ([\d.]+)/),
+    checkCommand("ttyd", ["--version"], /ttyd version ([\d.]+)/, true),
+  ]);
+
+  const ghAuth = await checkGhAuth();
+  const pluginChecks = await checkClaudePlugins();
+  const agentboardChecks = checkAgentBoard();
+
+  return {
+    timestamp: new Date().toISOString(),
+    tools,
+    ghAuth: ghAuth.ok,
+    plugins: pluginChecks.map(({ name, ok }) => ({ name, ok })),
+    agentboard: agentboardChecks.map(({ name, ok }) => ({ name, ok })),
+  };
+}

package/src/commands/doctor/format.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from "vitest";
+import { formatDoctorJson } from "./format.js";
+import type { DoctorRunResult } from "./checks.js";
+
+function makeResult(overrides: Partial<DoctorRunResult> = {}): DoctorRunResult {
+  return {
+    timestamp: "2024-06-01T12:00:00.000Z",
+    tools: [
+      { name: "git", version: "2.40.0", ok: true },
+      { name: "node", version: "20.11.0", ok: true },
+      { name: "bun", version: "1.1.0", ok: true },
+    ],
+    ghAuth: true,
+    plugins: [{ name: "code-simplifier", ok: true }],
+    agentboard: [{ name: "database", ok: true }],
+    ...overrides,
+  };
+}
+
+describe("formatDoctorJson", () => {
+  it("returns valid JSON with all fields", () => {
+    const result = makeResult();
+    const output = formatDoctorJson(result);
+    const parsed = JSON.parse(output);
+
+    expect(parsed.timestamp).toBe("2024-06-01T12:00:00.000Z");
+    expect(parsed.tools).toHaveLength(3);
+    expect(parsed.ghAuth).toBe(true);
+    expect(parsed.plugins).toHaveLength(1);
+    expect(parsed.agentboard).toHaveLength(1);
+  });
+
+  it("includes tool details", () => {
+    const result = makeResult();
+    const parsed = JSON.parse(formatDoctorJson(result));
+    const git = parsed.tools.find((t: { name: string }) => t.name === "git");
+
+    expect(git).toEqual({ name: "git", version: "2.40.0", ok: true });
+  });
+
+  it("includes warning field when present", () => {
+    const result = makeResult({
+      tools: [{ name: "ttyd", version: null, ok: true, warning: "optional, not installed" }],
+    });
+    const parsed = JSON.parse(formatDoctorJson(result));
+
+    expect(parsed.tools[0].warning).toBe("optional, not installed");
+  });
+
+  it("preserves ghAuth false", () => {
+    const result = makeResult({ ghAuth: false });
+    const parsed = JSON.parse(formatDoctorJson(result));
+
+    expect(parsed.ghAuth).toBe(false);
+  });
+
+  it("roundtrips through JSON.parse", () => {
+    const result = makeResult();
+    const parsed = JSON.parse(formatDoctorJson(result));
+
+    expect(parsed).toEqual(result);
+  });
+});

package/src/commands/doctor/format.ts

@@ -0,0 +1,5 @@
+import type { DoctorRunResult } from "./checks.js";
+
+export function formatDoctorJson(result: DoctorRunResult): string {
+  return JSON.stringify(result, null, 2);
+}