selftune 0.1.4 → 0.2.1

package/cli/selftune/init.ts

@@ -8,16 +8,25 @@
  *
  * Usage:
  *   selftune init [--agent <type>] [--cli-path <path>] [--force]
+ *   selftune init --enable-autonomy [--schedule-format cron|launchd|systemd]
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 
-import { SELFTUNE_CONFIG_DIR, SELFTUNE_CONFIG_PATH } from "./constants.js";
+import { CLAUDE_CODE_HOOK_KEYS, SELFTUNE_CONFIG_DIR, SELFTUNE_CONFIG_PATH } from "./constants.js";
 import type { SelftuneConfig } from "./types.js";
+import { hookKeyHasSelftuneEntry } from "./utils/hooks.js";
 import { detectAgent } from "./utils/llm-call.js";
 
 // ---------------------------------------------------------------------------
@@ -37,6 +46,7 @@ const VALID_AGENT_TYPES: SelftuneConfig["agent_type"][] = [
   "claude_code",
   "codex",
   "opencode",
+  "openclaw",
   "unknown",
 ];
 
@@ -44,6 +54,7 @@ const AGENT_TYPE_CLI_MAP: Record<string, string> = {
   claude_code: "claude",
   codex: "codex",
   opencode: "opencode",
+  openclaw: "openclaw",
 };
 
 function agentTypeToCli(agentType: string): string | null {
@@ -82,6 +93,12 @@ export function detectAgentType(
     return "opencode";
   }
 
+  // OpenClaw: agents directory or binary
+  const openclawDir = join(home, ".openclaw", "agents");
+  if (existsSync(openclawDir) || Bun.which("openclaw")) {
+    return "openclaw";
+  }
+
   return "unknown";
 }
 
@@ -116,8 +133,6 @@ export function determineLlmMode(agentCli: string | null): {
 // Hook detection (Claude Code only)
 // ---------------------------------------------------------------------------
 
-const REQUIRED_HOOK_KEYS = ["prompt-submit", "post-tool-use", "session-stop"] as const;
-
 /**
  * Check if the selftune hooks are configured in Claude Code settings.
  */
@@ -130,15 +145,10 @@ export function checkClaudeCodeHooks(settingsPath: string): boolean {
     const hooks = settings?.hooks;
     if (!hooks || typeof hooks !== "object") return false;
 
-    for (const key of REQUIRED_HOOK_KEYS) {
-      const entries = hooks[key];
-      if (!Array.isArray(entries) || entries.length === 0) return false;
-      // Check that at least one entry references selftune
-      const hasSelftune = entries.some(
-        (e: { command?: string }) =>
-          typeof e.command === "string" && e.command.includes("selftune"),
-      );
-      if (!hasSelftune) return false;
+    for (const key of CLAUDE_CODE_HOOK_KEYS) {
+      if (!hookKeyHasSelftuneEntry(hooks, key)) {
+        return false;
+      }
     }
 
     return true;
@@ -147,6 +157,274 @@ export function checkClaudeCodeHooks(settingsPath: string): boolean {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Hook installation (Claude Code only)
+// ---------------------------------------------------------------------------
+
+/** Bundled settings snippet (ships with the npm package). */
+const SETTINGS_SNIPPET_PATH = resolve(
+  dirname(import.meta.path),
+  "..",
+  "..",
+  "skill",
+  "settings_snippet.json",
+);
+
+/**
+ * Install selftune hooks into ~/.claude/settings.json by merging entries
+ * from the bundled settings_snippet.json.
+ *
+ * - Creates settings.json if it does not exist
+ * - Creates the hooks section if it does not exist
+ * - Only adds hook entries for keys that don't already have a selftune entry
+ * - Never overwrites existing user hooks
+ *
+ * Returns the list of hook keys that were added.
+ */
+export function installClaudeCodeHooks(options?: {
+  settingsPath?: string;
+  snippetPath?: string;
+  cliPath?: string;
+}): string[] {
+  const settingsPath = options?.settingsPath ?? join(homedir(), ".claude", "settings.json");
+  const snippetPath = options?.snippetPath ?? SETTINGS_SNIPPET_PATH;
+
+  // Read the snippet
+  if (!existsSync(snippetPath)) {
+    console.error(`[WARN] Hook snippet not found at ${snippetPath}, skipping hook installation`);
+    return [];
+  }
+
+  let snippet: Record<string, unknown>;
+  try {
+    snippet = JSON.parse(readFileSync(snippetPath, "utf-8"));
+  } catch {
+    console.error(`[WARN] Failed to parse hook snippet at ${snippetPath}`);
+    return [];
+  }
+
+  const snippetHooks = snippet.hooks as Record<string, unknown[]> | undefined;
+  if (!snippetHooks || typeof snippetHooks !== "object") {
+    console.error("[WARN] Hook snippet has no 'hooks' section");
+    return [];
+  }
+
+  // Read existing settings (or start with empty object)
+  let settings: Record<string, unknown> = {};
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    } catch {
+      console.error(`[WARN] Failed to parse ${settingsPath}, starting with empty settings`);
+      settings = {};
+    }
+  }
+
+  // Ensure hooks section exists
+  if (!settings.hooks || typeof settings.hooks !== "object") {
+    settings.hooks = {};
+  }
+  const existingHooks = settings.hooks as Record<string, unknown[]>;
+
+  // Resolve the CLI hooks directory for path substitution
+  const cliPath = options?.cliPath;
+  const hooksDir = cliPath ? `${dirname(cliPath)}/hooks` : null;
+
+  const addedKeys: string[] = [];
+
+  for (const key of Object.keys(snippetHooks)) {
+    // Skip if this key already has a selftune entry
+    if (hookKeyHasSelftuneEntry(existingHooks, key)) {
+      continue;
+    }
+
+    // Get the snippet entries for this key, replacing /PATH/TO/ with actual path
+    let entries = snippetHooks[key];
+    if (hooksDir) {
+      // Deep clone and substitute paths
+      const raw = JSON.stringify(entries).replace(/\/PATH\/TO\/cli\/selftune\/hooks/g, hooksDir);
+      entries = JSON.parse(raw);
+    }
+
+    // Merge: append to existing array or create new one
+    if (Array.isArray(existingHooks[key])) {
+      existingHooks[key] = [...existingHooks[key], ...entries];
+    } else {
+      existingHooks[key] = entries;
+    }
+
+    addedKeys.push(key);
+  }
+
+  if (addedKeys.length > 0) {
+    // Ensure ~/.claude/ directory exists
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+  }
+
+  return addedKeys;
+}
+
+// ---------------------------------------------------------------------------
+// Agent file installation
+// ---------------------------------------------------------------------------
+
+/** Bundled agent files directory (ships with the npm package). */
+const BUNDLED_AGENTS_DIR = resolve(dirname(import.meta.path), "..", "..", ".claude", "agents");
+
+/**
+ * Copy bundled agent markdown files to ~/.claude/agents/.
+ * Returns a list of file names that were copied (skips files that already exist
+ * unless `force` is true).
+ */
+export function installAgentFiles(options?: { homeDir?: string; force?: boolean }): string[] {
+  const home = options?.homeDir ?? homedir();
+  const force = options?.force ?? false;
+  const targetDir = join(home, ".claude", "agents");
+
+  if (!existsSync(BUNDLED_AGENTS_DIR)) return [];
+
+  let sourceFiles: string[];
+  try {
+    sourceFiles = readdirSync(BUNDLED_AGENTS_DIR).filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+
+  if (sourceFiles.length === 0) return [];
+
+  mkdirSync(targetDir, { recursive: true });
+
+  const copied: string[] = [];
+  for (const file of sourceFiles) {
+    const dest = join(targetDir, file);
+    if (!force && existsSync(dest)) continue;
+    copyFileSync(join(BUNDLED_AGENTS_DIR, file), dest);
+    copied.push(file);
+  }
+
+  return copied;
+}
+
+// ---------------------------------------------------------------------------
+// Workspace type detection
+// ---------------------------------------------------------------------------
+
+const IGNORE_DIRS = new Set(["node_modules", ".git", ".hg", "dist", "build", ".next", ".cache"]);
+
+export interface WorkspaceInfo {
+  type: "single-skill" | "multi-skill" | "monorepo" | "unknown";
+  skillCount: number;
+  skillPaths: string[];
+  isMonorepo: boolean;
+  hasExistingHooks: boolean;
+  suggestedTemplate: "single-skill" | "multi-skill" | null;
+}
+
+/**
+ * Recursively find SKILL.md files under a root directory,
+ * skipping ignored directories (node_modules, .git, etc.).
+ */
+function findSkillFiles(dir: string, maxDepth = 8, depth = 0): string[] {
+  if (depth > maxDepth) return [];
+  if (!existsSync(dir)) return [];
+
+  const results: string[] = [];
+
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (IGNORE_DIRS.has(entry.name)) continue;
+        results.push(...findSkillFiles(join(dir, entry.name), maxDepth, depth + 1));
+      } else if (entry.name === "SKILL.md") {
+        results.push(join(dir, entry.name));
+      }
+    }
+  } catch {
+    // Permission errors, etc. — skip
+  }
+
+  return results;
+}
+
+/**
+ * Detect whether the root directory is a monorepo by checking for
+ * package.json workspaces or pnpm-workspace.yaml.
+ */
+function detectMonorepo(rootDir: string): boolean {
+  // Check package.json workspaces field
+  const pkgPath = join(rootDir, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      if (pkg.workspaces) return true;
+    } catch {
+      // invalid JSON — skip
+    }
+  }
+
+  // Check pnpm-workspace.yaml
+  if (existsSync(join(rootDir, "pnpm-workspace.yaml"))) return true;
+
+  // Check lerna.json
+  if (existsSync(join(rootDir, "lerna.json"))) return true;
+
+  return false;
+}
+
+/**
+ * Detect whether the project has existing selftune hooks configured.
+ */
+function detectExistingHooks(rootDir: string): boolean {
+  const hooksDir = join(rootDir, "cli", "selftune", "hooks");
+  if (!existsSync(hooksDir)) return false;
+
+  try {
+    const entries = readdirSync(hooksDir);
+    return entries.some((e) => e.endsWith(".ts") || e.endsWith(".js"));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Scan a project root and detect the workspace type, skill layout,
+ * and suggest an appropriate template.
+ */
+export function detectWorkspaceType(rootDir: string): WorkspaceInfo {
+  const skillPaths = findSkillFiles(rootDir);
+  const isMonorepo = detectMonorepo(rootDir);
+  const hasExistingHooks = detectExistingHooks(rootDir);
+  const skillCount = skillPaths.length;
+
+  let type: WorkspaceInfo["type"];
+  let suggestedTemplate: WorkspaceInfo["suggestedTemplate"];
+
+  if (isMonorepo) {
+    type = "monorepo";
+    suggestedTemplate = "multi-skill";
+  } else if (skillCount === 0) {
+    type = "unknown";
+    suggestedTemplate = null;
+  } else if (skillCount === 1) {
+    type = "single-skill";
+    suggestedTemplate = "single-skill";
+  } else {
+    type = "multi-skill";
+    suggestedTemplate = "multi-skill";
+  }
+
+  return {
+    type,
+    skillCount,
+    skillPaths,
+    isMonorepo,
+    hasExistingHooks,
+    suggestedTemplate,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Init options (for testability)
 // ---------------------------------------------------------------------------
@@ -219,6 +497,34 @@ export function runInit(opts: InitOptions): SelftuneConfig {
   mkdirSync(configDir, { recursive: true });
   writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
 
+  // Install agent files to ~/.claude/agents/
+  const copiedAgents = installAgentFiles({ homeDir: home, force });
+  if (copiedAgents.length > 0) {
+    console.error(`[INFO] Installed agent files: ${copiedAgents.join(", ")}`);
+  }
+
+  // Auto-install hooks into ~/.claude/settings.json (Claude Code only)
+  if (agentType === "claude_code") {
+    const addedHookKeys = installClaudeCodeHooks({
+      settingsPath,
+      cliPath,
+    });
+    if (addedHookKeys.length > 0) {
+      config.hooks_installed = true;
+      // Re-write config with updated hooks_installed flag
+      writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+      console.error(
+        `[INFO] Installed ${addedHookKeys.length} selftune hook(s) into ${settingsPath}: ${addedHookKeys.join(", ")}`,
+      );
+    } else if (!config.hooks_installed) {
+      // Re-check in case hooks were already present
+      config.hooks_installed = checkClaudeCodeHooks(settingsPath);
+      if (config.hooks_installed) {
+        writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+      }
+    }
+  }
+
   return config;
 }
 
@@ -232,6 +538,8 @@ export async function cliMain(): Promise<void> {
       agent: { type: "string" },
       "cli-path": { type: "string" },
       force: { type: "boolean", default: false },
+      "enable-autonomy": { type: "boolean", default: false },
+      "schedule-format": { type: "string" },
     },
     strict: true,
   });
@@ -239,9 +547,10 @@ export async function cliMain(): Promise<void> {
   const configDir = SELFTUNE_CONFIG_DIR;
   const configPath = SELFTUNE_CONFIG_PATH;
   const force = values.force ?? false;
+  const enableAutonomy = values["enable-autonomy"] ?? false;
 
   // Check for existing config without force
-  if (!force && existsSync(configPath)) {
+  if (!force && !enableAutonomy && existsSync(configPath)) {
     try {
       const raw = readFileSync(configPath, "utf-8");
       const existing = JSON.parse(raw) as SelftuneConfig;
@@ -265,12 +574,63 @@ export async function cliMain(): Promise<void> {
 
   console.log(JSON.stringify(config, null, 2));
 
+  // Detect workspace type and report
+  const workspace = detectWorkspaceType(process.cwd());
+  console.log(
+    JSON.stringify({
+      level: "info",
+      code: "workspace_detected",
+      type: workspace.type,
+      skills: workspace.skillCount,
+      monorepo: workspace.isMonorepo,
+      suggestedTemplate: workspace.suggestedTemplate
+        ? `templates/${workspace.suggestedTemplate}-settings.json`
+        : null,
+    }),
+  );
+
   // Run doctor as post-check
   const { doctor } = await import("./observability.js");
   const doctorResult = doctor();
-  console.error(
-    `\n[doctor] ${doctorResult.summary.pass}/${doctorResult.summary.total} checks pass`,
+  console.log(
+    JSON.stringify({
+      level: "info",
+      code: "doctor_result",
+      pass: doctorResult.summary.pass,
+      total: doctorResult.summary.total,
+    }),
   );
+
+  if (enableAutonomy) {
+    try {
+      const { installSchedule } = await import("./schedule.js");
+      const scheduleResult = installSchedule({
+        format: values["schedule-format"],
+      });
+
+      if (!scheduleResult.activated) {
+        console.error(
+          "Failed to activate the autonomous scheduler. Re-run with --schedule-format or use `selftune schedule --install --dry-run` to inspect the generated artifacts first.",
+        );
+        process.exit(1);
+      }
+
+      console.log(
+        JSON.stringify({
+          level: "info",
+          code: "autonomy_enabled",
+          format: scheduleResult.format,
+          activated: scheduleResult.activated,
+          files: scheduleResult.artifacts.map((artifact) => artifact.path),
+        }),
+      );
+    } catch (err) {
+      console.error(
+        `Failed to enable autonomy: ${err instanceof Error ? err.message : String(err)}`,
+      );
+      process.exit(1);
+    }
+  }
 }
 
 // Guard: only run when invoked directly

package/cli/selftune/last.ts

@@ -4,9 +4,14 @@
  * Lightweight, no LLM calls.
  */
 
-import { QUERY_LOG, SKILL_LOG, TELEMETRY_LOG } from "./constants.js";
+import { QUERY_LOG, TELEMETRY_LOG } from "./constants.js";
 import type { QueryLogRecord, SessionTelemetryRecord, SkillUsageRecord } from "./types.js";
 import { readJsonl } from "./utils/jsonl.js";
+import {
+  filterActionableQueryRecords,
+  filterActionableSkillUsageRecords,
+} from "./utils/query-filter.js";
+import { readEffectiveSkillUsageRecords } from "./utils/skill-log.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -36,6 +41,8 @@ export function computeLastInsight(
   queryRecords: QueryLogRecord[],
 ): LastSessionInsight | null {
   if (telemetry.length === 0) return null;
+  const actionableSkillRecords = filterActionableSkillUsageRecords(skillRecords);
+  const actionableQueryRecords = filterActionableQueryRecords(queryRecords);
 
   // Find most recent telemetry record
   const sorted = [...telemetry].sort(
@@ -48,17 +55,19 @@ export function computeLastInsight(
   const triggeredSkillQueries = new Set<string>();
   const skillsTriggered = [
     ...new Set(
-      skillRecords
+      actionableSkillRecords
         .filter((r) => r.session_id === sessionId && r.triggered)
         .map((r) => {
-          triggeredSkillQueries.add(r.query.toLowerCase().trim());
+          if (typeof r.query === "string") {
+            triggeredSkillQueries.add(r.query.toLowerCase().trim());
+          }
           return r.skill_name;
         }),
     ),
   ];
 
   // Unmatched queries: session queries whose text does NOT appear in any triggered skill record
-  const sessionQueries = queryRecords.filter((r) => r.session_id === sessionId);
+  const sessionQueries = actionableQueryRecords.filter((r) => r.session_id === sessionId);
   const unmatchedQueries = sessionQueries
     .filter((q) => !triggeredSkillQueries.has(q.query.toLowerCase().trim()))
     .map((q) => q.query);
@@ -124,7 +133,7 @@ export function formatInsight(insight: LastSessionInsight): string {
 /** CLI main: reads logs, prints insight. */
 export function cliMain(): void {
   const telemetry = readJsonl<SessionTelemetryRecord>(TELEMETRY_LOG);
-  const skillRecords = readJsonl<SkillUsageRecord>(SKILL_LOG);
+  const skillRecords = readEffectiveSkillUsageRecords();
   const queryRecords = readJsonl<QueryLogRecord>(QUERY_LOG);
 
   const insight = computeLastInsight(telemetry, skillRecords, queryRecords);

package/cli/selftune/localdb/db.ts

@@ -0,0 +1,63 @@
+/**
+ * SQLite database lifecycle for selftune local materialized view store.
+ *
+ * Uses Bun's built-in SQLite driver. The database file lives at
+ * ~/.selftune/selftune.db and is treated as a disposable cache —
+ * it can always be rebuilt from the authoritative JSONL logs.
+ */
+
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { SELFTUNE_CONFIG_DIR } from "../constants.js";
+import { ALL_DDL } from "./schema.js";
+
+/** Default database file path. */
+export const DB_PATH = join(SELFTUNE_CONFIG_DIR, "selftune.db");
+
+/**
+ * Open (or create) the selftune SQLite database at the given path.
+ * Runs all DDL to ensure the schema exists. Uses WAL mode for
+ * concurrent read/write safety.
+ *
+ * Pass ":memory:" for an in-memory database (useful for tests).
+ */
+export function openDb(dbPath: string = DB_PATH): Database {
+  // Ensure parent directory exists for file-based databases
+  if (dbPath !== ":memory:") {
+    const dir = dirname(dbPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  const db = new Database(dbPath);
+
+  // Enable WAL mode for better concurrent access
+  db.run("PRAGMA journal_mode = WAL");
+  db.run("PRAGMA foreign_keys = ON");
+
+  // Run all DDL statements
+  for (const ddl of ALL_DDL) {
+    db.run(ddl);
+  }
+
+  return db;
+}
+
+/**
+ * Get a metadata value from the _meta table.
+ */
+export function getMeta(db: Database, key: string): string | null {
+  const row = db.query("SELECT value FROM _meta WHERE key = ?").get(key) as {
+    value: string;
+  } | null;
+  return row?.value ?? null;
+}
+
+/**
+ * Set a metadata value in the _meta table.
+ */
+export function setMeta(db: Database, key: string, value: string): void {
+  db.run("INSERT OR REPLACE INTO _meta (key, value) VALUES (?, ?)", [key, value]);
+}