ccdesk 0.2.1 → 0.2.3

package/dist/view/sections/permissions.js

@@ -0,0 +1,87 @@
+import {} from "../../shared/types.js";
+import { suggestedRules } from "../usage.js";
+import { defineSection } from "./types.js";
+export function isSuggested(row) {
+    return "suggested" in row;
+}
+/**
+ * An allow rule in effect that covered none of the calls counted here. Ask rules are not flagged:
+ * they guard calls, so one that never fired is no reason to remove it.
+ */
+export function unused(rule, usage) {
+    return (rule.kind === "rule" &&
+        rule.list === "allow" &&
+        rule.inEffect &&
+        !rule.decidedBy &&
+        (usage?.sessions ?? 0) > 0 &&
+        usage?.matches[rule.rule] === 0);
+}
+const LIST_ORDER = ["deny", "ask", "allow"];
+/** Rules in the order Claude Code checks their lists, then other settings, then suggestions. */
+function listRank(row) {
+    if (isSuggested(row))
+        return 4;
+    return row.item.kind === "rule" ? LIST_ORDER.indexOf(row.item.list) : 3;
+}
+/** A row as words: its list and rule, or the setting and its value. */
+function words(row) {
+    if (isSuggested(row))
+        return `suggested allow ${row.item.rule}`;
+    const { item } = row;
+    return item.kind === "rule" ? `${item.list} ${item.rule}` : `${item.kind} ${item.value}`;
+}
+export const permissions = defineSection({
+    id: "permissions",
+    title: "Permissions",
+    rows: (view) => {
+        const ids = new Set();
+        const set = view.permissions.map((item) => {
+            // Keyed by content so a selection survives a refresh; a repeated entry gets a suffix.
+            const base = `perm:${item.scope}:${item.kind === "rule" ? `${item.list}:${item.rule}` : `${item.kind}:${item.value}`}`;
+            let id = base;
+            for (let n = 2; ids.has(id); n++)
+                id = `${base}#${n}`;
+            ids.add(id);
+            return { id, section: "permissions", line: item.scope, item };
+        });
+        const suggested = suggestedRules(view).map((item) => ({
+            id: `perm:suggested:${item.rule}`,
+            section: "permissions",
+            line: null,
+            item,
+            suggested: true,
+        }));
+        return [...set, ...suggested];
+    },
+    columns: [
+        { label: "", sort: (r) => (isSuggested(r) ? "~" : r.item.scope) },
+        {
+            label: "List",
+            sort: listRank,
+        },
+        {
+            label: "Rule",
+            sort: (r) => ("rule" in r.item ? r.item.rule : r.item.value),
+        },
+        { label: "Outcome" },
+    ],
+    empty: () => "No settings file sets permissions here, so Claude asks before using tools that need it.",
+    dimmed: (row) => !isSuggested(row) &&
+        (!row.item.inEffect || (row.item.kind === "rule" && row.item.decidedBy !== undefined)),
+    text: (row) => `permission ${words(row)}`,
+    label: words,
+    heading: (row) => {
+        if ("rule" in row.item)
+            return row.item.rule;
+        return row.item.kind === "defaultMode" ? "Default permission mode" : "Extra folder";
+    },
+    facet: {
+        label: "Filter permissions by list",
+        of: (row) => {
+            if (isSuggested(row))
+                return "suggested";
+            return row.item.kind === "rule" ? row.item.list : "other";
+        },
+        order: () => ["deny", "ask", "allow", "other", "suggested"],
+    },
+});

package/dist/view/sections/settings.d.ts

@@ -0,0 +1 @@
+export declare const settings: import("./types.ts").ViewSection<import("./types.ts").Row>;

package/dist/view/sections/settings.js

@@ -0,0 +1,33 @@
+import { HIGHEST_FIRST } from "../../shared/scopes.js";
+import {} from "../../shared/types.js";
+import {} from "../lines.js";
+import { defineSection } from "./types.js";
+export const settings = defineSection({
+    id: "settings",
+    title: "Settings",
+    rows: (view) => view.effective.map((item) => {
+        const lines = item.from;
+        return {
+            id: `set:${item.key}`,
+            section: "settings",
+            line: lines[lines.length - 1] ?? "user",
+            item,
+            lines,
+        };
+    }),
+    columns: [
+        { label: "", sort: (r) => HIGHEST_FIRST.indexOf((r.item.from[0] ?? "user")) },
+        { label: "Key", sort: (r) => r.item.key },
+        { label: "Value" },
+        { label: "Overrides" },
+    ],
+    empty: () => "No settings files set anything here.",
+    // The Overrides column only earns its space when some value beats or merges with another file.
+    tableClass: (rows) => rows.some((r) => r.item.merged || r.item.overridden.length > 0 || r.item.ignored.length > 0)
+        ? ""
+        : "no-overrides",
+    dimmed: (row) => row.item.from.length === 0,
+    text: (row) => `${row.item.key} ${JSON.stringify(row.item.value)}`,
+    label: (row) => `setting ${row.item.key}`,
+    heading: (row) => row.item.key,
+});

package/dist/view/sections/tools.d.ts

@@ -0,0 +1,6 @@
+import { type BuiltinTool, type Usage } from "../../shared/types.ts";
+/** Calls counted here: undefined while counting, null when the transcripts could not be read. */
+export declare function callsOf(usage: Usage | null | undefined, name: string): number | null | undefined;
+/** What happens when Claude wants the tool, in Manual mode. */
+export declare function outcome(tool: BuiltinTool): string;
+export declare const tools: import("./types.ts").ViewSection<import("./types.ts").Row>;

package/dist/view/sections/tools.js

@@ -0,0 +1,57 @@
+import {} from "../../shared/types.js";
+import { defineSection } from "./types.js";
+/** Calls counted here: undefined while counting, null when the transcripts could not be read. */
+export function callsOf(usage, name) {
+    if (!usage)
+        return usage;
+    return usage.tools.find((t) => t.tool === name)?.calls ?? 0;
+}
+/** What happens when Claude wants the tool, in Manual mode. */
+export function outcome(tool) {
+    switch (tool.verdict) {
+        case "denied":
+            return "removed";
+        case "asks":
+            return "asks every time";
+        case "allowed":
+            return "runs without asking";
+        case "default":
+            return tool.asks ? "asks first" : "no approval needed";
+    }
+}
+export const tools = defineSection({
+    id: "tools",
+    title: "Built-in tools",
+    short: "Tools",
+    rows: (view) => view.tools.map((item) => ({
+        id: `tool:${item.name}`,
+        section: "tools",
+        line: item.decidedBy?.scope ?? null,
+        item,
+        calls: callsOf(view.usage, item.name),
+    })),
+    columns: [
+        { label: "" },
+        { label: "Tool", sort: (r) => r.item.name },
+        { label: "Outcome", sort: (r) => outcome(r.item) },
+        { label: "Rules and hooks", sort: (r) => r.item.scoped.length + r.item.hooks },
+        { label: "Used", sort: (r) => r.calls ?? -1 },
+        { label: "Description" },
+    ],
+    empty: () => "ccdesk has no list of built-in tools.",
+    dimmed: (row) => row.item.verdict === "denied",
+    text: (row) => `tool ${row.item.name} ${outcome(row.item)} ${row.item.description}`,
+    label: (row) => `tool ${row.item.name}`,
+    heading: (row) => row.item.name,
+    facet: {
+        label: "Filter tools by outcome",
+        of: (row) => outcome(row.item),
+        order: () => [
+            "removed",
+            "asks every time",
+            "asks first",
+            "runs without asking",
+            "no approval needed",
+        ],
+    },
+});

package/dist/view/sections/types.d.ts

@@ -0,0 +1,123 @@
+import { type Approval, type BuiltinTool, type CatalogSetting, type DirectoryView, type EffectiveSetting, type Entry, type Hook, type Instruction, type McpServer, type Memory, type Permission, type Plugin, type Reference } from "../../shared/types.ts";
+import { type Formatter } from "../format.ts";
+import { type Line } from "../lines.ts";
+export type EntryKind = "agent" | "skill" | "command" | "output style";
+/** One table row; `id` stays the same across reloads so a selection survives them. */
+export type Row = {
+    id: string;
+    section: "instructions";
+    line: Line;
+    item: Instruction;
+    order: number;
+} | {
+    id: string;
+    section: "settings";
+    line: Line;
+    item: EffectiveSetting;
+    lines: Line[];
+} | {
+    id: string;
+    section: "permissions";
+    line: Line;
+    item: Permission;
+}
+/** Calls you approved by hand that an allow rule not yet in any file would cover. */
+ | {
+    id: string;
+    section: "permissions";
+    line: null;
+    item: Approval;
+    suggested: true;
+}
+/** A tool no rule names as a whole belongs to no scope. */
+ | {
+    id: string;
+    section: "tools";
+    line: Line | null;
+    item: BuiltinTool;
+    /** Calls in the sessions started here; undefined while counting, null if counting failed. */
+    calls: number | null | undefined;
+} | {
+    id: string;
+    section: "memory";
+    line: Line;
+    item: Memory;
+} | {
+    id: string;
+    section: "hooks";
+    line: Line;
+    item: Hook;
+} | {
+    id: string;
+    section: "mcp";
+    line: Line;
+    item: McpServer;
+}
+/** A documented setting; its line is the file that sets it here, if any. */
+ | {
+    id: string;
+    section: "catalog";
+    line: Line | null;
+    item: CatalogSetting;
+    set?: EffectiveSetting;
+} | {
+    id: string;
+    section: "extensions";
+    line: Line;
+    item: Entry;
+    kind: EntryKind;
+} | {
+    id: string;
+    section: "extensions";
+    line: Line;
+    item: Plugin;
+    kind: "plugin";
+};
+export type SectionId = Row["section"];
+export type RowOf<S extends SectionId> = Extract<Row, {
+    section: S;
+}>;
+/** What sections need besides the directory: how to show paths, and Claude Code's settings data. */
+export interface ViewContext {
+    format: Formatter;
+    /** From `REFERENCE` in the core, or `/api/reference` in the page. */
+    reference: Reference;
+}
+export interface Column<R> {
+    label: string;
+    /** Sort key; columns without one cannot be sorted. */
+    sort?: (row: R) => string | number;
+}
+/** Rows of one section narrowed by a value, such as memory by type. */
+export interface Facet<R> {
+    label: string;
+    of: (row: R) => string;
+    /** The order values are offered in; values not listed come after, by name. */
+    order?: (context: ViewContext) => string[];
+}
+/** How one kind of row is listed: its rows, columns and the text that names them. */
+export interface ViewSection<R extends Row> {
+    id: R["section"];
+    title: string;
+    /** A shorter title for the section index, when the title is long. */
+    short?: string;
+    rows: (view: DirectoryView, context: ViewContext) => R[];
+    columns: Column<R>[];
+    empty: (view: DirectoryView) => string;
+    /** Rows that exist but do not take effect are drawn faded. */
+    dimmed?: (row: R) => boolean;
+    /** Text the filter box and the palette search. */
+    text: (row: R) => string;
+    /** One line naming the row in the palette. */
+    label: (row: R, context: ViewContext) => string;
+    /** The inspector's heading for a row. */
+    heading: (row: R, context: ViewContext) => string;
+    facet?: Facet<R>;
+    /** An extra class for the table, from the rows on it. */
+    tableClass?: (rows: R[]) => string;
+}
+/**
+ * Lets the registry hold every section in one list. Sound because a row is only ever handed to
+ * the section that made it, looked up by `row.section`.
+ */
+export declare function defineSection<R extends Row>(section: ViewSection<R>): ViewSection<Row>;

package/dist/view/sections/types.js

@@ -0,0 +1,10 @@
+import {} from "../../shared/types.js";
+import {} from "../format.js";
+import {} from "../lines.js";
+/**
+ * Lets the registry hold every section in one list. Sound because a row is only ever handed to
+ * the section that made it, looked up by `row.section`.
+ */
+export function defineSection(section) {
+    return section;
+}

package/dist/view/settings.d.ts

@@ -0,0 +1,12 @@
+import { type SettingSchema } from "../shared/types.ts";
+/** How a setting is edited: typed controls where the schema allows it, JSON otherwise. */
+export type FieldKind = "boolean" | "enum" | "number" | "string" | "lines" | "json";
+export declare function fieldKind(property: SettingSchema | undefined): FieldKind;
+/**
+ * The string values a settings reference type lists, such as theme's "dark" and "light": offered as
+ * choices where the schema allows any string. In a bulleted list only the value opening each bullet
+ * counts, since the explanations quote other values. Inline, only a list the type states is taken
+ * ("one of", "the string"), up to a ";" or "such as", so examples and remarks are not;
+ * placeholders like "custom:<slug>" are left out.
+ */
+export declare function valuesIn(type: string): string[];

package/dist/view/settings.js

@@ -0,0 +1,31 @@
+import {} from "../shared/types.js";
+export function fieldKind(property) {
+    if (!property)
+        return "json";
+    if (property.enum?.every((v) => typeof v === "string"))
+        return "enum";
+    if (property.type === "boolean")
+        return "boolean";
+    if (property.type === "number" || property.type === "integer")
+        return "number";
+    if (property.type === "string")
+        return "string";
+    if (property.type === "array" && property.items?.type === "string" && !property.items.enum)
+        return "lines";
+    return "json";
+}
+/**
+ * The string values a settings reference type lists, such as theme's "dark" and "light": offered as
+ * choices where the schema allows any string. In a bulleted list only the value opening each bullet
+ * counts, since the explanations quote other values. Inline, only a list the type states is taken
+ * ("one of", "the string"), up to a ";" or "such as", so examples and remarks are not;
+ * placeholders like "custom:<slug>" are left out.
+ */
+export function valuesIn(type) {
+    const bullets = [...type.matchAll(/^\* `"([^"`<>]+)"`/gm)].map((m) => m[1] ?? "");
+    const clause = (type.split("\n")[0] ?? "").split(/;| such as /)[0] ?? "";
+    const inline = /one of|the string|^string, `"/.test(clause)
+        ? [...clause.matchAll(/`"([^"`<>]+)"`/g)].map((m) => m[1] ?? "")
+        : [];
+    return [...new Set((bullets.length > 0 ? bullets : inline).filter(Boolean))];
+}

package/dist/view/usage.d.ts

@@ -0,0 +1,8 @@
+import { type DirectoryView, type Usage } from "../shared/types.ts";
+/** "the 12 sessions started in this repository since 3 Oct", for sentences about counted calls. */
+export declare function sessionsHere(usage: Usage): string;
+/**
+ * Suggested allow rules, most approved first. The server leaves out rules that would change
+ * nothing; this also drops one saved since the counts were taken, until they are taken again.
+ */
+export declare function suggestedRules(view: DirectoryView): Usage["approvals"];

package/dist/view/usage.js

@@ -0,0 +1,18 @@
+import {} from "../shared/types.js";
+import { plural } from "./format.js";
+/** "the 12 sessions started in this repository since 3 Oct", for sentences about counted calls. */
+export function sessionsHere(usage) {
+    const since = usage.since
+        ? ` since ${new Date(usage.since).toLocaleDateString(undefined, { day: "numeric", month: "short" })}`
+        : "";
+    const where = usage.repository ? "in this repository" : "here";
+    return `${usage.sessions === 1 ? "the session" : `the ${plural(usage.sessions, "session")}`} started ${where}${since}`;
+}
+/**
+ * Suggested allow rules, most approved first. The server leaves out rules that would change
+ * nothing; this also drops one saved since the counts were taken, until they are taken again.
+ */
+export function suggestedRules(view) {
+    const decided = new Set(view.permissions.flatMap((p) => (p.kind === "rule" && p.inEffect ? [p.rule] : [])));
+    return (view.usage?.approvals ?? []).filter((a) => !decided.has(a.rule));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccdesk",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "See and change everything Claude Code loads on your machine: instruction files, settings, permissions, hooks, MCP servers, subagents, skills, plugins and auto memory",
   "keywords": [
     "claude-code",
@@ -30,6 +30,17 @@
   "bin": {
     "ccdesk": "dist/server/cli.js"
   },
+  "exports": {
+    ".": {
+      "types": "./dist/core/index.d.ts",
+      "default": "./dist/core/index.js"
+    },
+    "./view": {
+      "types": "./dist/view/index.d.ts",
+      "default": "./dist/view/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
     "dist/",
     "README.md",
@@ -62,7 +73,7 @@
     "access": "public"
   },
   "dependencies": {
-    "ajv": "8.20.0",
+    "typebox": "1.3.36",
     "yaml": "2.9.1"
   },
   "devDependencies": {