@drdeeks/character-kit 1.0.1

package/node/src/memory/index.js

@@ -0,0 +1,355 @@
+import fs from "fs/promises";
+import path from "path";
+import yaml from "js-yaml";
+
+export class DailyNotes {
+  constructor(workspace) {
+    this.workspace = workspace || process.cwd();
+    this.dailyDir = path.join(this.workspace, "memory", "daily");
+  }
+
+  async init() {
+    await fs.mkdir(this.dailyDir, { recursive: true });
+  }
+
+  _todayFile() {
+    const date = new Date().toISOString().split("T")[0];
+    return path.join(this.dailyDir, `${date}.yaml`);
+  }
+
+  async log(entry, options = {}) {
+    const filePath = this._todayFile();
+    const now = new Date().toISOString();
+
+    let data;
+    try {
+      const raw = await fs.readFile(filePath, "utf-8");
+      data = yaml.load(raw) || {};
+    } catch {
+      data = {
+        date: now.split("T")[0],
+        created_at: now,
+        entries: [],
+      };
+    }
+
+    data.entries.push({
+      timestamp: now,
+      content: entry,
+      tags: options.tags || [],
+      category: options.category || "general",
+    });
+    data.updated_at = now;
+
+    await fs.writeFile(filePath, yaml.dump(data, { lineWidth: -1 }));
+    return { status: "logged", file: filePath };
+  }
+
+  async getToday() {
+    try {
+      const raw = await fs.readFile(this._todayFile(), "utf-8");
+      return yaml.load(raw) || {};
+    } catch {
+      return { date: new Date().toISOString().split("T")[0], entries: [] };
+    }
+  }
+
+  async getRange(startDate, endDate) {
+    const results = [];
+    const start = new Date(startDate);
+    const end = new Date(endDate);
+
+    for (let d = new Date(start); d <= end; d.setDate(d.getDate() + 1)) {
+      const dateStr = d.toISOString().split("T")[0];
+      const filePath = path.join(this.dailyDir, `${dateStr}.yaml`);
+      try {
+        const raw = await fs.readFile(filePath, "utf-8");
+        results.push(yaml.load(raw) || {});
+      } catch {}
+    }
+
+    return results;
+  }
+
+  async listNotes() {
+    const notes = [];
+    try {
+      const files = await fs.readdir(this.dailyDir);
+      const yamlFiles = files.filter((f) => f.endsWith(".yaml")).sort().reverse();
+      for (const f of yamlFiles) {
+        const raw = await fs.readFile(path.join(this.dailyDir, f), "utf-8");
+        const data = yaml.load(raw) || {};
+        notes.push({
+          date: data.date || f.replace(".yaml", ""),
+          file: path.join(this.dailyDir, f),
+          entries: (data.entries || []).length,
+        });
+      }
+    } catch {}
+    return notes;
+  }
+}
+
+export class WeeklyDigest {
+  constructor(workspace) {
+    this.workspace = workspace || process.cwd();
+    this.weeklyDir = path.join(this.workspace, "memory", "weekly");
+  }
+
+  async init() {
+    await fs.mkdir(this.weeklyDir, { recursive: true });
+  }
+
+  async create(weekStart, summary, options = {}) {
+    const filePath = path.join(this.weeklyDir, `week-${weekStart}.yaml`);
+    const now = new Date().toISOString();
+
+    const data = {
+      week_start: weekStart,
+      created_at: now,
+      summary,
+      patterns: options.patterns || [],
+      decisions: options.decisions || [],
+    };
+
+    await fs.writeFile(filePath, yaml.dump(data, { lineWidth: -1 }));
+    return { status: "created", file: filePath };
+  }
+
+  async get(weekStart) {
+    const filePath = path.join(this.weeklyDir, `week-${weekStart}.yaml`);
+    try {
+      const raw = await fs.readFile(filePath, "utf-8");
+      return yaml.load(raw) || {};
+    } catch {
+      return {};
+    }
+  }
+
+  async listDigests() {
+    const digests = [];
+    try {
+      const files = await fs.readdir(this.weeklyDir);
+      const yamlFiles = files.filter((f) => f.startsWith("week-") && f.endsWith(".yaml")).sort().reverse();
+      for (const f of yamlFiles) {
+        const raw = await fs.readFile(path.join(this.weeklyDir, f), "utf-8");
+        const data = yaml.load(raw) || {};
+        digests.push({
+          weekStart: data.week_start || f.replace("week-", "").replace(".yaml", ""),
+          file: path.join(this.weeklyDir, f),
+          patterns: (data.patterns || []).length,
+        });
+      }
+    } catch {}
+    return digests;
+  }
+}
+
+export class LongTermMemory {
+  constructor(workspace) {
+    this.workspace = workspace || process.cwd();
+    this.filePath = path.join(this.workspace, "memory", "long-term.yaml");
+  }
+
+  async init() {
+    await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+  }
+
+  async _load() {
+    try {
+      const raw = await fs.readFile(this.filePath, "utf-8");
+      return yaml.load(raw) || { lessons: [], patterns: [], decisions: [] };
+    } catch {
+      return { lessons: [], patterns: [], decisions: [] };
+    }
+  }
+
+  async _save(data) {
+    data.updated_at = new Date().toISOString();
+    await fs.writeFile(this.filePath, yaml.dump(data, { lineWidth: -1 }));
+  }
+
+  async addLesson(title, content, options = {}) {
+    const data = await this._load();
+    data.lessons.push({
+      title,
+      content,
+      tags: options.tags || [],
+      category: options.category || "general",
+      added_at: new Date().toISOString(),
+    });
+    await this._save(data);
+    return { status: "added", total: data.lessons.length };
+  }
+
+  async addPattern(name, description, examples = []) {
+    const data = await this._load();
+    data.patterns.push({
+      name,
+      description,
+      examples,
+      added_at: new Date().toISOString(),
+    });
+    await this._save(data);
+    return { status: "added", total: data.patterns.length };
+  }
+
+  async addDecision(title, context, decision, rationale) {
+    const data = await this._load();
+    data.decisions.push({
+      title,
+      context,
+      decision,
+      rationale,
+      made_at: new Date().toISOString(),
+    });
+    await this._save(data);
+    return { status: "added", total: data.decisions.length };
+  }
+
+  async search(query) {
+    const data = await this._load();
+    const q = query.toLowerCase();
+    const results = [];
+
+    for (const lesson of data.lessons || []) {
+      if ((lesson.title + lesson.content).toLowerCase().includes(q)) {
+        results.push({ type: "lesson", ...lesson });
+      }
+    }
+    for (const pattern of data.patterns || []) {
+      if ((pattern.name + pattern.description).toLowerCase().includes(q)) {
+        results.push({ type: "pattern", ...pattern });
+      }
+    }
+    for (const decision of data.decisions || []) {
+      if ((decision.title + decision.decision).toLowerCase().includes(q)) {
+        results.push({ type: "decision", ...decision });
+      }
+    }
+    return results;
+  }
+
+  async getAll() {
+    return this._load();
+  }
+}
+
+export class KnowledgeGraph {
+  constructor(workspace) {
+    this.workspace = workspace || process.cwd();
+    this.entitiesDir = path.join(this.workspace, "knowledge", "entities");
+  }
+
+  async init() {
+    await fs.mkdir(this.entitiesDir, { recursive: true });
+  }
+
+  _entityFile(name) {
+    return path.join(this.entitiesDir, `${name.toLowerCase().replace(/[\s]+/g, "-")}.yaml`);
+  }
+
+  async addEntity(name, type, facts = {}, tags = []) {
+    const filePath = this._entityFile(name);
+    const now = new Date().toISOString();
+
+    let existing = {};
+    try {
+      const raw = await fs.readFile(filePath, "utf-8");
+      existing = yaml.load(raw) || {};
+    } catch {}
+
+    const data = {
+      name,
+      type,
+      tags,
+      facts,
+      created_at: existing.created_at || now,
+      updated_at: now,
+    };
+
+    await fs.writeFile(filePath, yaml.dump(data, { lineWidth: -1 }));
+    return { status: "added", file: filePath };
+  }
+
+  async getEntity(name) {
+    try {
+      const raw = await fs.readFile(this._entityFile(name), "utf-8");
+      return yaml.load(raw) || {};
+    } catch {
+      return {};
+    }
+  }
+
+  async searchEntities(query) {
+    const results = [];
+    try {
+      const files = await fs.readdir(this.entitiesDir);
+      for (const f of files) {
+        if (!f.endsWith(".yaml")) continue;
+        const raw = await fs.readFile(path.join(this.entitiesDir, f), "utf-8");
+        const data = yaml.load(raw) || {};
+        if (JSON.stringify(data).toLowerCase().includes(query.toLowerCase())) {
+          results.push(data);
+        }
+      }
+    } catch {}
+    return results;
+  }
+
+  async listEntities(type = null) {
+    const entities = [];
+    try {
+      const files = await fs.readdir(this.entitiesDir);
+      for (const f of files) {
+        if (!f.endsWith(".yaml")) continue;
+        const raw = await fs.readFile(path.join(this.entitiesDir, f), "utf-8");
+        const data = yaml.load(raw) || {};
+        if (type && data.type !== type) continue;
+        entities.push({ name: data.name, type: data.type, file: path.join(this.entitiesDir, f) });
+      }
+    } catch {}
+    return entities;
+  }
+}
+
+export class Memory {
+  constructor(workspace) {
+    this.workspace = workspace || process.cwd();
+    this.daily = new DailyNotes(this.workspace);
+    this.weekly = new WeeklyDigest(this.workspace);
+    this.longterm = new LongTermMemory(this.workspace);
+    this.knowledge = new KnowledgeGraph(this.workspace);
+  }
+
+  async init() {
+    await Promise.all([
+      this.daily.init(),
+      this.weekly.init(),
+      this.longterm.init(),
+      this.knowledge.init(),
+    ]);
+  }
+
+  async status() {
+    const dailyNotes = await this.daily.listNotes();
+    const weeklyDigests = await this.weekly.listDigests();
+    const longterm = await this.longterm.getAll();
+    const entities = await this.knowledge.listEntities();
+
+    return {
+      dailyNotes: dailyNotes.length,
+      weeklyDigests: weeklyDigests.length,
+      longtermLessons: (longterm.lessons || []).length,
+      longtermPatterns: (longterm.patterns || []).length,
+      longtermDecisions: (longterm.decisions || []).length,
+      entities: entities.length,
+    };
+  }
+
+  async search(query) {
+    const longterm = await this.longterm.search(query);
+    const entities = await this.knowledge.searchEntities(query);
+    return { longterm, entities };
+  }
+}

package/node/tests/character.test.js

@@ -0,0 +1,80 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { processToolCall, generateConfig } from "../src/index.js";
+import { DocumentIndexer } from "../src/knowledge/indexer.js";
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+// ─── Identity hook ───────────────────────────────────────────────────────────
+
+test("hook formats Claude allow decision", async () => {
+  const { output, exitCode } = await processToolCall(
+    { tool_name: "Bash", tool_input: { command: "ls" }, hook_event_name: "PreToolUse" },
+    { framework: "claude", enforcer: { validateTool: async () => ({ allowed: true }) } }
+  );
+  assert.equal(output.hookSpecificOutput.permissionDecision, "allow");
+  assert.equal(exitCode, 0);
+});
+
+test("hook fails CLOSED when enforcer unreachable", async () => {
+  const { output, exitCode } = await processToolCall(
+    { tool_name: "Bash", tool_input: { command: "rm -rf /" }, hook_event_name: "PreToolUse" },
+    { framework: "claude", enforcer: { validateTool: async () => ({ allowed: false, error: true, reason: "down" }) } }
+  );
+  assert.equal(output.hookSpecificOutput.permissionDecision, "deny");
+  assert.equal(exitCode, 2);
+});
+
+test("generateConfig emits claude/cursor/gemini blocks", () => {
+  const claude = generateConfig("claude");
+  const cursor = generateConfig("cursor");
+  const gemini = generateConfig("gemini");
+  assert.ok(claude.hooks.PreToolUse);
+  assert.ok(cursor.hooks.preToolUse);
+  assert.ok(gemini.hooks.BeforeTool);
+});
+
+// ─── Indexer: discovery + frontmatter + links ─────────────────────────────────
+
+function makeWorkspace() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "aik-test-"));
+  fs.writeFileSync(path.join(dir, "notes.md"), "# Notes\nSee [[guide]].\n");
+  fs.writeFileSync(path.join(dir, "guide.md"), "# Guide\nthe authentication flow lives here\n");
+  fs.writeFileSync(path.join(dir, "code.py"), "x = 1\n");
+  return dir;
+}
+
+test("indexer discovers broad file types and injects frontmatter", async () => {
+  const dir = makeWorkspace();
+  const idx = new DocumentIndexer(dir);
+  await idx.init();
+  const res = await idx.indexDirectory(dir, {});
+  assert.equal(res.indexed, 3);
+  const yaml = fs.readFileSync(path.join(dir, "knowledge", "documents", "notes.yaml"), "utf-8");
+  assert.match(yaml, /^---[\s\S]*?id:/);
+  assert.match(yaml, /category:/);
+});
+
+test("indexer documents wiki links", async () => {
+  const dir = makeWorkspace();
+  const idx = new DocumentIndexer(dir);
+  await idx.init();
+  await idx.indexDirectory(dir, {});
+  const notes = Object.values(idx.index.documents).find((d) => d.path.endsWith("notes.md"));
+  assert.ok(notes.links.includes("guide"));
+  assert.ok(Object.keys(idx.index.links).length >= 1);
+});
+
+test("indexer excludes agent-internal files (SOUL.md, constitution)", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "aik-excl-"));
+  fs.writeFileSync(path.join(dir, "SOUL.md"), "# Soul\n");
+  fs.mkdirSync(path.join(dir, ".agent"), { recursive: true });
+  fs.writeFileSync(path.join(dir, ".agent", "constitution.yaml"), "agent:\n  id: x\n");
+  fs.writeFileSync(path.join(dir, "userdoc.md"), "real corpus doc\n");
+  const idx = new DocumentIndexer(dir);
+  await idx.init();
+  const res = await idx.indexDirectory(dir, {});
+  assert.equal(res.indexed, 1);
+  assert.ok(Object.keys(idx.index.documents).some((k) => k.endsWith("userdoc")));
+});

package/node/tests/habit-create.test.js

@@ -0,0 +1,67 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import net from "node:net";
+
+const REPO = path.resolve(process.cwd());
+const INSTALL = path.join(REPO, "node", "bin", "install.js");
+const DAEMON = path.join(REPO, "node", "enforcer", "agent_enforcer_daemon.js");
+
+function rpc(sock, method, params) {
+  return new Promise((res, rej) => {
+    const c = net.connect(sock, () => c.write(JSON.stringify({ method, params }) + "\n"));
+    let buf = "";
+    c.on("data", (d) => {
+      buf += d.toString();
+      if (buf.includes("\n")) { c.end(); try { res(JSON.parse(buf.split("\n")[0])); } catch (e) { rej(e); } }
+    });
+    c.on("error", rej);
+    setTimeout(() => rej(new Error("timeout")), 5000);
+  });
+}
+
+test("create-habit generates a valid habit file that the daemon indexes", { timeout: 20000 }, async () => {
+  const ws = fs.mkdtempSync(path.join(os.tmpdir(), "ackhabit-"));
+  const sock = path.join(ws, ".agent", "enforcer.sock");
+
+  // create the habit non-interactively
+  const cr = spawn(process.execPath, [INSTALL, "--create-habit",
+    "--workspace", ws,
+    "--habit-name", "always-verify-before-ship",
+    "--habit-prompt", "Did I actually verify this runs before claiming done?",
+    "--habit-logic", "A thing that parses can still be wrong, so proof requires execution."], { stdio: ["ignore", "pipe", "pipe"] });
+  let errOut = "";
+  cr.stderr.on("data", (d) => (errOut += d));
+  cr.stdout.on("data", (d) => (errOut += d));
+  await new Promise((r) => cr.on("exit", r));
+
+  const file = path.join(ws, ".agent", "habits", "always_verify_before_ship.yaml");
+  if (!fs.existsSync(file)) {
+    console.log("CREATE-HABIT OUTPUT:", errOut);
+  }
+  assert.ok(fs.existsSync(file), "habit yaml should be written");
+  const text = fs.readFileSync(file, "utf8");
+  assert.ok(/name: "always_verify_before_ship"/.test(text), "name normalized to snake_case");
+  assert.ok(/prompt: "Did I actually verify this runs before claiming done\?"/.test(text), "prompt field present");
+
+  // boot the daemon pointing at this workspace; the new habit must be known
+  const env = { ...process.env, AGENT_WORKSPACE: ws, ENFORCER_SOCKET: sock, HOME: os.homedir() };
+  fs.mkdirSync(path.join(ws, ".agent", "habits"), { recursive: true });
+  const child = spawn(process.execPath, [DAEMON], { env, detached: true, stdio: "ignore" });
+  child.unref();
+  const start = Date.now();
+  while (!fs.existsSync(sock) && Date.now() - start < 3000) await new Promise((r) => setTimeout(r, 50));
+
+  // the new habit should be acknowledged (known) by the daemon
+  const ack = await rpc(sock, "submit_ack", {
+    session_id: "hb",
+    statement: "Habit: always_verify_before_ship why: it applies because the daemon loaded it from the freshly created habit file",
+  });
+  assert.equal(ack.ok, true, "daemon should know the newly created habit");
+
+  try { process.kill(-child.pid, "SIGKILL"); } catch {}
+  fs.rmSync(ws, { recursive: true, force: true });
+});

package/node/tests/habits-default.test.js

@@ -0,0 +1,68 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import net from "node:net";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const REPO = path.resolve(process.cwd());
+const DAEMON = path.join(REPO, "node", "enforcer", "agent_enforcer_daemon.js");
+const SRC = path.join(REPO, "python", "example_workspace", ".agent", "habits");
+
+// The decision-logic habits extracted from the user's named sources:
+//   /home/ubuntu/qwen-cloud-2026/FOREVER-SYSTEM.md  (full 10-section protocol)
+//   /home/ubuntu/qwen-cloud-2026/drdeeks-skills/skill-creator/references/standards.md
+// These are part of the DEFAULT bundled set (seeded by install.js).
+const EXTRACTED = [
+  // FOREVER-SYSTEM.md (faithful to the full protocol, not a summary)
+  "single_source_of_truth", "layered_not_rewritten", "fail_closed_tamper_evident",
+  "affirm_character_each_action", "track_defects_openly", "test_of_forever",
+  "rename_as_layer_op", "check_duplication_before_debug",
+  "drift_signal_detection", "registered_plugin_not_string", "audit_not_silent",
+  "binding_map_one_core", "character_hash_visible", "forever_one_idea",
+  // skill-creator standards.md (§5/§6/§10/§4)
+  "idempotent_operations", "documented_rollback", "graceful_degradation",
+  "timeout_and_retry", "lossless_consolidation", "safe_file_permissions",
+  "one_concern_per_file",
+];
+
+function rpc(sock, method, params) {
+  return new Promise((res, rej) => {
+    const c = net.connect(sock, () => c.write(JSON.stringify({ method, params }) + "\n"));
+    let buf = "";
+    c.on("data", (d) => {
+      buf += d;
+      if (buf.includes("\n")) { c.end(); try { res(JSON.parse(buf.split("\n")[0])); } catch (e) { rej(e); } }
+    });
+    c.on("error", rej);
+  });
+}
+
+test("default bundled habits include the 15 extracted decision-logic habits", async () => {
+  const ws = fs.mkdtempSync(path.join(os.tmpdir(), "ackdefault-"));
+  fs.mkdirSync(path.join(ws, ".agent", "habits"), { recursive: true });
+  for (const f of fs.readdirSync(SRC)) {
+    fs.copyFileSync(path.join(SRC, f), path.join(ws, ".agent", "habits", f));
+  }
+  const sock = path.join(ws, ".agent", "enforcer.sock");
+  const d = spawn(process.execPath, [DAEMON], {
+    env: { ...process.env, AGENT_WORKSPACE: ws, ENFORCER_SOCKET: sock }, stdio: "ignore",
+  });
+
+  let known = [];
+  try {
+    await new Promise((r) => setTimeout(r, 700));
+    for (let i = 1; i <= 5; i++) {
+      const r = await rpc(sock, "tool_tick", { session_id: "default-test", tool: "terminal" });
+      if (r.hold) { known = r.habits || []; break; }
+    }
+  } finally {
+    d.kill();
+  }
+
+  assert.ok(known.length >= 32, `expected >=32 default habits, got ${known.length}`);
+  for (const name of EXTRACTED) {
+    assert.ok(known.includes(name), `extracted habit missing from default set: ${name}`);
+  }
+});

package/node/tests/install-chain.test.js

@@ -0,0 +1,19 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+
+const REPO = path.resolve(process.cwd());
+const INSTALL = path.join(REPO, "node", "bin", "install.js");
+
+test("install.js exists and is valid JavaScript", { timeout: 5000 }, async () => {
+  // Just verify the install script exists and is syntactically valid
+  assert.ok(fs.existsSync(INSTALL), "install.js should exist");
+  
+  const content = fs.readFileSync(INSTALL, "utf8");
+  assert.ok(content.includes("export { parseArgs, resolveSocket }"), "should export parseArgs and resolveSocket");
+  assert.ok(content.includes("async function main()"), "should have main function");
+  assert.ok(content.includes("launchDaemon"), "should have launchDaemon function");
+  assert.ok(content.includes("seedHabits"), "should have seedHabits function");
+  assert.ok(content.includes("writeConstitution"), "should have writeConstitution function");
+});