@eltonssouza/development-utility-kit 1.0.0

package/.claude/skills/honcho-memory/tests/t003-honcho-client.test.js

@@ -0,0 +1,162 @@
+/**
+ * T-003: Verify honcho-client.js module
+ *
+ * Failing tests to be written BEFORE implementation.
+ * Verifies:
+ * - lib/honcho-client.js exists and is importable
+ * - exports all 6 required functions
+ * - all functions return null on error (never throw)
+ * - functions work with timeout
+ * - degradation graceful on unreachable host
+ */
+
+import { existsSync } from "fs";
+import { join } from "path";
+
+const SKILL_DIR = new URL("../", import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1");
+const CLIENT_FILE = join(SKILL_DIR, "lib", "honcho-client.js");
+
+// Test 1: lib/honcho-client.js must exist
+const test1 = () => {
+  if (!existsSync(CLIENT_FILE)) {
+    throw new Error(`lib/honcho-client.js does not exist at: ${CLIENT_FILE}`);
+  }
+  console.log("PASS: lib/honcho-client.js exists");
+};
+
+// Test 2: module must export 6 required functions
+const test2 = async () => {
+  const mod = await import(CLIENT_FILE);
+  const required = ["getOrCreateApp", "getOrCreateSession", "saveMemory", "searchMemories", "listMemories", "deleteMemory"];
+  const missing = required.filter((fn) => typeof mod[fn] !== "function");
+  if (missing.length > 0) {
+    throw new Error(`lib/honcho-client.js missing exports: ${missing.join(", ")}`);
+  }
+  console.log("PASS: all 6 functions exported");
+};
+
+// Test 3: createClient must be exported and return a client object
+const test3 = async () => {
+  const mod = await import(CLIENT_FILE);
+  if (typeof mod.createClient !== "function") {
+    throw new Error("lib/honcho-client.js missing export: createClient");
+  }
+  const client = mod.createClient({ baseUrl: "http://localhost:19999", apiKey: "test", timeoutMs: 100 });
+  if (!client || typeof client !== "object") {
+    throw new Error("createClient() did not return an object");
+  }
+  const required = ["getOrCreateApp", "getOrCreateSession", "saveMemory", "searchMemories", "listMemories", "deleteMemory"];
+  const missing = required.filter((fn) => typeof client[fn] !== "function");
+  if (missing.length > 0) {
+    throw new Error(`Client object missing methods: ${missing.join(", ")}`);
+  }
+  console.log("PASS: createClient() returns object with all 6 methods");
+};
+
+// Test 4: getOrCreateApp returns null on unreachable host (no throw)
+const test4 = async () => {
+  const { createClient } = await import(CLIENT_FILE);
+  const client = createClient({ baseUrl: "http://localhost:19999", apiKey: "test-key", timeoutMs: 200 });
+  const result = await client.getOrCreateApp("test-workspace");
+  if (result !== null) {
+    throw new Error(`Expected null on connection failure, got: ${JSON.stringify(result)}`);
+  }
+  console.log("PASS: getOrCreateApp returns null on unreachable host");
+};
+
+// Test 5: getOrCreateSession returns null on unreachable host (no throw)
+const test5 = async () => {
+  const { createClient } = await import(CLIENT_FILE);
+  const client = createClient({ baseUrl: "http://localhost:19999", apiKey: "test-key", timeoutMs: 200 });
+  const result = await client.getOrCreateSession("ws", "session-id");
+  if (result !== null) {
+    throw new Error(`Expected null on connection failure, got: ${JSON.stringify(result)}`);
+  }
+  console.log("PASS: getOrCreateSession returns null on unreachable host");
+};
+
+// Test 6: saveMemory returns null on unreachable host (no throw)
+const test6 = async () => {
+  const { createClient } = await import(CLIENT_FILE);
+  const client = createClient({ baseUrl: "http://localhost:19999", apiKey: "test-key", timeoutMs: 200 });
+  const result = await client.saveMemory("ws", "session-id", "peer-id", "test content", {});
+  if (result !== null) {
+    throw new Error(`Expected null on connection failure, got: ${JSON.stringify(result)}`);
+  }
+  console.log("PASS: saveMemory returns null on unreachable host");
+};
+
+// Test 7: searchMemories returns null on unreachable host (no throw)
+const test7 = async () => {
+  const { createClient } = await import(CLIENT_FILE);
+  const client = createClient({ baseUrl: "http://localhost:19999", apiKey: "test-key", timeoutMs: 200 });
+  const result = await client.searchMemories("ws", "peer-id", "query");
+  if (result !== null) {
+    throw new Error(`Expected null on connection failure, got: ${JSON.stringify(result)}`);
+  }
+  console.log("PASS: searchMemories returns null on unreachable host");
+};
+
+// Test 8: listMemories returns null on unreachable host (no throw)
+const test8 = async () => {
+  const { createClient } = await import(CLIENT_FILE);
+  const client = createClient({ baseUrl: "http://localhost:19999", apiKey: "test-key", timeoutMs: 200 });
+  const result = await client.listMemories("ws", "session-id");
+  if (result !== null) {
+    throw new Error(`Expected null on connection failure, got: ${JSON.stringify(result)}`);
+  }
+  console.log("PASS: listMemories returns null on unreachable host");
+};
+
+// Test 9: deleteMemory returns null on unreachable host (no throw)
+const test9 = async () => {
+  const { createClient } = await import(CLIENT_FILE);
+  const client = createClient({ baseUrl: "http://localhost:19999", apiKey: "test-key", timeoutMs: 200 });
+  const result = await client.deleteMemory("ws", "session-id");
+  if (result !== null) {
+    throw new Error(`Expected null on connection failure, got: ${JSON.stringify(result)}`);
+  }
+  console.log("PASS: deleteMemory returns null on unreachable host");
+};
+
+// Test 10: all operations complete within 2x timeout (graceful timeout enforcement)
+const test10 = async () => {
+  const { createClient } = await import(CLIENT_FILE);
+  const client = createClient({ baseUrl: "http://localhost:19999", apiKey: "test-key", timeoutMs: 200 });
+  const start = Date.now();
+  await Promise.all([
+    client.getOrCreateApp("ws"),
+    client.getOrCreateSession("ws", "s"),
+    client.saveMemory("ws", "s", "p", "content", {}),
+  ]);
+  const elapsed = Date.now() - start;
+  // Each runs independently but all should complete within 3x timeout (generous allowance)
+  if (elapsed > 3000) {
+    throw new Error(`Operations took ${elapsed}ms, expected < 3000ms`);
+  }
+  console.log(`PASS: all operations completed within time limit (${elapsed}ms)`);
+};
+
+// Test 11: loadConfig function exported and readable
+const test11 = async () => {
+  const mod = await import(CLIENT_FILE);
+  if (typeof mod.loadConfig !== "function") {
+    throw new Error("lib/honcho-client.js missing export: loadConfig");
+  }
+  console.log("PASS: loadConfig exported");
+};
+
+// Run all tests
+let failed = 0;
+const tests = [test1, test2, test3, test4, test5, test6, test7, test8, test9, test10, test11];
+for (const t of tests) {
+  try {
+    await t();
+  } catch (e) {
+    console.error(`FAIL: ${e.message}`);
+    failed++;
+  }
+}
+
+console.log(`\nResults: ${tests.length - failed}/${tests.length} passed`);
+process.exit(failed > 0 ? 1 : 0);

package/.claude/skills/honcho-memory/tests/t004-soft-delete.test.js

@@ -0,0 +1,259 @@
+/**
+ * T-004: Verify softDeleteMemory + deleted-filter helpers in honcho-client.js
+ *
+ * Tests are written BEFORE implementation (TDD RED phase).
+ * Verifies:
+ * - softDeleteMemory is exported as a function
+ * - createClient() returns an object that includes softDeleteMemory
+ * - softDeleteMemory returns null on unreachable host (never throws)
+ * - softDeleteMemory uses PUT method (verified via mock)
+ * - listMemories client-side filter excludes metadata.deleted = true
+ * - searchMemories client-side filter excludes metadata.deleted = true
+ * - All 6 original functions remain intact and exported
+ */
+
+import { existsSync } from "fs";
+import { join } from "path";
+
+const SKILL_DIR = new URL("../", import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1");
+const CLIENT_FILE = join(SKILL_DIR, "lib", "honcho-client.js");
+
+// Test 1: softDeleteMemory must be exported as standalone function
+const test1 = async () => {
+  const mod = await import(CLIENT_FILE);
+  if (typeof mod.softDeleteMemory !== "function") {
+    throw new Error("lib/honcho-client.js missing export: softDeleteMemory");
+  }
+  console.log("PASS: softDeleteMemory exported as standalone function");
+};
+
+// Test 2: createClient() must return object with softDeleteMemory method
+const test2 = async () => {
+  const { createClient } = await import(CLIENT_FILE);
+  const client = createClient({ baseUrl: "http://localhost:19999", apiKey: "test", timeoutMs: 100 });
+  if (typeof client.softDeleteMemory !== "function") {
+    throw new Error("createClient() object missing softDeleteMemory method");
+  }
+  console.log("PASS: createClient() includes softDeleteMemory method");
+};
+
+// Test 3: softDeleteMemory returns null on unreachable host (never throws)
+const test3 = async () => {
+  const { createClient } = await import(CLIENT_FILE);
+  const client = createClient({ baseUrl: "http://localhost:19999", apiKey: "test-key", timeoutMs: 200 });
+  const result = await client.softDeleteMemory("ws", "session-id", "message-id");
+  if (result !== null) {
+    throw new Error(`Expected null on connection failure, got: ${JSON.stringify(result)}`);
+  }
+  console.log("PASS: softDeleteMemory returns null on unreachable host");
+};
+
+// Test 4: standalone softDeleteMemory returns null when config missing
+const test4 = async () => {
+  // Call without config — should return null gracefully (config not found or test env)
+  const { softDeleteMemory } = await import(CLIENT_FILE);
+  // In test env config may not exist; if it does this still must not throw
+  let threw = false;
+  try {
+    await softDeleteMemory("ws", "session-id", "message-id");
+  } catch {
+    threw = true;
+  }
+  if (threw) {
+    throw new Error("standalone softDeleteMemory must not throw — must return null");
+  }
+  console.log("PASS: standalone softDeleteMemory never throws");
+};
+
+// Test 5: all 7 functions are now exported (6 original + softDeleteMemory)
+const test5 = async () => {
+  const mod = await import(CLIENT_FILE);
+  const required = [
+    "getOrCreateApp",
+    "getOrCreateSession",
+    "saveMemory",
+    "searchMemories",
+    "listMemories",
+    "deleteMemory",
+    "softDeleteMemory",
+  ];
+  const missing = required.filter((fn) => typeof mod[fn] !== "function");
+  if (missing.length > 0) {
+    throw new Error(`lib/honcho-client.js missing exports: ${missing.join(", ")}`);
+  }
+  console.log("PASS: all 7 standalone functions exported");
+};
+
+// Test 6: createClient object has all 7 methods
+const test6 = async () => {
+  const { createClient } = await import(CLIENT_FILE);
+  const client = createClient({ baseUrl: "http://localhost:19999", apiKey: "test", timeoutMs: 100 });
+  const required = [
+    "getOrCreateApp",
+    "getOrCreateSession",
+    "saveMemory",
+    "searchMemories",
+    "listMemories",
+    "deleteMemory",
+    "softDeleteMemory",
+  ];
+  const missing = required.filter((fn) => typeof client[fn] !== "function");
+  if (missing.length > 0) {
+    throw new Error(`createClient() object missing methods: ${missing.join(", ")}`);
+  }
+  console.log("PASS: createClient() object has all 7 methods");
+};
+
+// Test 7: softDeleteMemory uses PUT via interceptable mock
+// We verify that the function signature accepts (workspaceId, sessionId, messageId)
+const test7 = async () => {
+  const { createClient } = await import(CLIENT_FILE);
+
+  let capturedMethod = null;
+  let capturedUrl = null;
+  let capturedBody = null;
+
+  // Patch globalThis.fetch to intercept the request
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (url, opts) => {
+    capturedMethod = opts?.method;
+    capturedUrl = url;
+    capturedBody = opts?.body ? JSON.parse(opts.body) : null;
+    // Return a mock successful response
+    return {
+      ok: true,
+      status: 200,
+      json: async () => ({ id: "msg-1", metadata: { deleted: true } }),
+    };
+  };
+
+  try {
+    const client = createClient({ baseUrl: "http://mock-host", apiKey: "test-key", timeoutMs: 200 });
+    await client.softDeleteMemory("my-workspace", "my-session", "my-message-id");
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+
+  if (capturedMethod !== "PUT") {
+    throw new Error(`Expected PUT method, got: ${capturedMethod}`);
+  }
+  if (!capturedUrl.includes("my-workspace") || !capturedUrl.includes("my-session") || !capturedUrl.includes("my-message-id")) {
+    throw new Error(`URL does not contain expected path segments: ${capturedUrl}`);
+  }
+  if (!capturedBody?.metadata?.deleted) {
+    throw new Error(`Expected body { metadata: { deleted: true } }, got: ${JSON.stringify(capturedBody)}`);
+  }
+  console.log("PASS: softDeleteMemory uses PUT with correct URL and body");
+};
+
+// Test 8: listMemories client-side filter excludes deleted messages
+const test8 = async () => {
+  const { createClient } = await import(CLIENT_FILE);
+
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (url, opts) => {
+    return {
+      ok: true,
+      status: 200,
+      json: async () => ({
+        items: [
+          { id: "m1", content: "keep me", metadata: { type: "explicit", deleted: false } },
+          { id: "m2", content: "soft deleted", metadata: { type: "explicit", deleted: true } },
+          { id: "m3", content: "also keep", metadata: { type: "inferred" } },
+          { id: "m4", content: "also deleted", metadata: { type: "project-context", deleted: true } },
+        ],
+        total: 4,
+      }),
+    };
+  };
+
+  let result;
+  try {
+    const client = createClient({ baseUrl: "http://mock-host", apiKey: "test-key", timeoutMs: 200 });
+    result = await client.listMemories("ws", "session-id");
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+
+  if (!result) {
+    throw new Error("listMemories returned null when it should return filtered results");
+  }
+  const items = result.items ?? result;
+  const deletedItems = (Array.isArray(items) ? items : []).filter((m) => m.metadata?.deleted === true);
+  if (deletedItems.length > 0) {
+    throw new Error(`listMemories returned ${deletedItems.length} soft-deleted item(s) — must be filtered out`);
+  }
+  const keptCount = Array.isArray(items) ? items.length : 0;
+  if (keptCount !== 2) {
+    throw new Error(`Expected 2 non-deleted items, got ${keptCount}: ${JSON.stringify(items)}`);
+  }
+  console.log("PASS: listMemories filters out metadata.deleted = true items");
+};
+
+// Test 9: searchMemories client-side filter excludes deleted messages
+const test9 = async () => {
+  const { createClient } = await import(CLIENT_FILE);
+
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (url, opts) => {
+    return {
+      ok: true,
+      status: 200,
+      json: async () => ({
+        items: [
+          { id: "s1", content: "relevant result", metadata: { type: "explicit" }, score: 0.9 },
+          { id: "s2", content: "soft deleted result", metadata: { type: "explicit", deleted: true }, score: 0.8 },
+          { id: "s3", content: "another result", metadata: { type: "inferred" }, score: 0.7 },
+        ],
+        total: 3,
+      }),
+    };
+  };
+
+  let result;
+  try {
+    const client = createClient({ baseUrl: "http://mock-host", apiKey: "test-key", timeoutMs: 200 });
+    result = await client.searchMemories("ws", "peer-id", "test query");
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+
+  if (!result) {
+    throw new Error("searchMemories returned null when it should return filtered results");
+  }
+  const items = result.items ?? result;
+  const deletedItems = (Array.isArray(items) ? items : []).filter((m) => m.metadata?.deleted === true);
+  if (deletedItems.length > 0) {
+    throw new Error(`searchMemories returned ${deletedItems.length} soft-deleted item(s) — must be filtered out`);
+  }
+  const keptCount = Array.isArray(items) ? items.length : 0;
+  if (keptCount !== 2) {
+    throw new Error(`Expected 2 non-deleted items, got ${keptCount}: ${JSON.stringify(items)}`);
+  }
+  console.log("PASS: searchMemories filters out metadata.deleted = true items");
+};
+
+// Test 10: DoD check — bun -e import returns 0 for softDeleteMemory
+const test10 = async () => {
+  const mod = await import(CLIENT_FILE);
+  const exitCode = typeof mod.softDeleteMemory === "function" ? 0 : 1;
+  if (exitCode !== 0) {
+    throw new Error("DoD FAIL: softDeleteMemory not exported as function");
+  }
+  console.log("PASS: DoD — softDeleteMemory is exported and is a function (exit 0)");
+};
+
+// Run all tests
+let failed = 0;
+const tests = [test1, test2, test3, test4, test5, test6, test7, test8, test9, test10];
+for (const t of tests) {
+  try {
+    await t();
+  } catch (e) {
+    console.error(`FAIL: ${e.message}`);
+    failed++;
+  }
+}
+
+console.log(`\nT-004 Results: ${tests.length - failed}/${tests.length} passed`);
+process.exit(failed > 0 ? 1 : 0);

package/.claude/skills/honcho-memory/tests/t005-memory-injector.test.js

@@ -0,0 +1,175 @@
+/**
+ * T-005: Verify lib/memory-injector.js
+ *
+ * Tests are written BEFORE implementation (TDD RED phase).
+ * Verifies:
+ * - memory-injector.js exists and is importable
+ * - exports buildContextBlock function
+ * - output contains [HONCHO MEMORY] and [/HONCHO MEMORY] tags
+ * - formats metadata (type, timestamp, project)
+ * - limit 2000 chars (BR-007)
+ * - empty array returns empty string or minimal block
+ * - content is included in block
+ */
+
+import { existsSync } from "fs";
+import { join } from "path";
+
+const SKILL_DIR = new URL("../", import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1");
+const INJECTOR_FILE = join(SKILL_DIR, "lib", "memory-injector.js");
+
+// Test 1: lib/memory-injector.js must exist
+const test1 = () => {
+  if (!existsSync(INJECTOR_FILE)) {
+    throw new Error(`lib/memory-injector.js does not exist at: ${INJECTOR_FILE}`);
+  }
+  console.log("PASS: lib/memory-injector.js exists");
+};
+
+// Test 2: must export buildContextBlock
+const test2 = async () => {
+  const mod = await import(INJECTOR_FILE);
+  if (typeof mod.buildContextBlock !== "function") {
+    throw new Error("lib/memory-injector.js missing export: buildContextBlock");
+  }
+  console.log("PASS: buildContextBlock exported");
+};
+
+// Test 3: buildContextBlock([]) returns empty string (no memories = no block)
+const test3 = async () => {
+  const { buildContextBlock } = await import(INJECTOR_FILE);
+  const result = buildContextBlock([]);
+  if (typeof result !== "string") {
+    throw new Error(`buildContextBlock([]) must return string, got: ${typeof result}`);
+  }
+  // Empty array = no block injected (return empty string)
+  if (result.trim() !== "") {
+    // Also acceptable: return empty tags — but empty string is preferred
+    // Only fail if it contains actual content
+    if (!result.includes("[HONCHO MEMORY]")) {
+      throw new Error(`buildContextBlock([]) returned unexpected non-empty: ${result}`);
+    }
+  }
+  console.log("PASS: buildContextBlock([]) returns empty or empty block");
+};
+
+// Test 4: single memory produces block with [HONCHO MEMORY] and [/HONCHO MEMORY]
+const test4 = async () => {
+  const { buildContextBlock } = await import(INJECTOR_FILE);
+  const memories = [{ content: "test content", metadata: { type: "explicit" } }];
+  const result = buildContextBlock(memories);
+  if (!result.includes("[HONCHO MEMORY]")) {
+    throw new Error("Output missing [HONCHO MEMORY] opening tag");
+  }
+  if (!result.includes("[/HONCHO MEMORY]")) {
+    throw new Error("Output missing [/HONCHO MEMORY] closing tag");
+  }
+  console.log("PASS: output contains [HONCHO MEMORY] and [/HONCHO MEMORY]");
+};
+
+// Test 5: output contains memory content
+const test5 = async () => {
+  const { buildContextBlock } = await import(INJECTOR_FILE);
+  const memories = [{ content: "prefiro records imutáveis em DTOs Java", metadata: { type: "explicit" } }];
+  const result = buildContextBlock(memories);
+  if (!result.includes("prefiro records imutáveis em DTOs Java")) {
+    throw new Error("Output does not contain memory content");
+  }
+  console.log("PASS: output contains memory content");
+};
+
+// Test 6: output contains type metadata
+const test6 = async () => {
+  const { buildContextBlock } = await import(INJECTOR_FILE);
+  const memories = [{ content: "test", metadata: { type: "explicit" } }];
+  const result = buildContextBlock(memories);
+  if (!result.includes("explicit")) {
+    throw new Error("Output does not include type metadata 'explicit'");
+  }
+  console.log("PASS: output contains type metadata");
+};
+
+// Test 7: output contains timestamp metadata when provided
+const test7 = async () => {
+  const { buildContextBlock } = await import(INJECTOR_FILE);
+  const ts = "2026-05-26T10:00:00.000Z";
+  const memories = [{ content: "test", metadata: { type: "explicit", timestamp: ts } }];
+  const result = buildContextBlock(memories);
+  if (!result.includes(ts)) {
+    throw new Error(`Output does not include timestamp: ${ts}`);
+  }
+  console.log("PASS: output contains timestamp metadata");
+};
+
+// Test 8: output contains project metadata when provided
+const test8 = async () => {
+  const { buildContextBlock } = await import(INJECTOR_FILE);
+  const memories = [{ content: "test", metadata: { type: "explicit", project: "development-utility-kit" } }];
+  const result = buildContextBlock(memories);
+  if (!result.includes("development-utility-kit")) {
+    throw new Error("Output does not include project metadata");
+  }
+  console.log("PASS: output contains project metadata");
+};
+
+// Test 9: output is limited to 2000 chars (BR-007)
+const test9 = async () => {
+  const { buildContextBlock } = await import(INJECTOR_FILE);
+  // Create memories that would exceed 2000 chars
+  const bigContent = "x".repeat(500);
+  const memories = Array.from({ length: 10 }, (_, i) => ({
+    content: `Memory ${i}: ${bigContent}`,
+    metadata: { type: "explicit", project: "test-project" },
+  }));
+  const result = buildContextBlock(memories);
+  if (result.length > 2000) {
+    throw new Error(`Output exceeds 2000 chars: ${result.length} chars`);
+  }
+  console.log(`PASS: output limited to 2000 chars (got ${result.length} chars)`);
+};
+
+// Test 10: multiple memories are all included (within limit)
+const test10 = async () => {
+  const { buildContextBlock } = await import(INJECTOR_FILE);
+  const memories = [
+    { content: "first memory", metadata: { type: "explicit" } },
+    { content: "second memory", metadata: { type: "inferred" } },
+    { content: "third memory", metadata: { type: "project-context" } },
+  ];
+  const result = buildContextBlock(memories);
+  if (!result.includes("first memory")) {
+    throw new Error("Output missing first memory content");
+  }
+  if (!result.includes("second memory")) {
+    throw new Error("Output missing second memory content");
+  }
+  if (!result.includes("third memory")) {
+    throw new Error("Output missing third memory content");
+  }
+  console.log("PASS: multiple memories included in output");
+};
+
+// Test 11: DoD check — import + buildContextBlock([{content:'test',metadata:{type:'explicit'}}]) contains [HONCHO MEMORY]
+const test11 = async () => {
+  const { buildContextBlock } = await import(INJECTOR_FILE);
+  const result = buildContextBlock([{ content: "test", metadata: { type: "explicit" } }]);
+  if (!result.includes("[HONCHO MEMORY]")) {
+    throw new Error("DoD FAIL: result does not contain [HONCHO MEMORY]");
+  }
+  console.log("PASS: DoD — buildContextBlock returns string containing [HONCHO MEMORY]");
+};
+
+// Run all tests
+let failed = 0;
+const tests = [test1, test2, test3, test4, test5, test6, test7, test8, test9, test10, test11];
+for (const t of tests) {
+  try {
+    await t();
+  } catch (e) {
+    console.error(`FAIL: ${e.message}`);
+    failed++;
+  }
+}
+
+console.log(`\nT-005 Results: ${tests.length - failed}/${tests.length} passed`);
+process.exit(failed > 0 ? 1 : 0);