@hasna/microservices 0.0.9 → 0.0.11

package/microservices/microservice-compliance/src/db/database.ts

@@ -0,0 +1,93 @@
+/**
+ * Database connection for microservice-compliance
+ */
+
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { MIGRATIONS } from "./migrations.js";
+
+let _db: Database | null = null;
+
+function getDbPath(): string {
+  // Environment variable override
+  if (process.env["MICROSERVICES_DIR"]) {
+    return join(process.env["MICROSERVICES_DIR"], "microservice-compliance", "data.db");
+  }
+
+  // Check for .microservices in current or parent directories
+  let dir = resolve(process.cwd());
+  while (true) {
+    const candidate = join(dir, ".microservices", "microservice-compliance", "data.db");
+    const msDir = join(dir, ".microservices");
+    if (existsSync(msDir)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  // Global fallback
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  return join(home, ".microservices", "microservice-compliance", "data.db");
+}
+
+function ensureDir(filePath: string): void {
+  const dir = dirname(resolve(filePath));
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+export function getDatabase(): Database {
+  if (_db) return _db;
+
+  const dbPath = getDbPath();
+  ensureDir(dbPath);
+
+  _db = new Database(dbPath);
+  _db.exec("PRAGMA journal_mode = WAL");
+  _db.exec("PRAGMA foreign_keys = ON");
+
+  // Create migrations table
+  _db.exec(`
+    CREATE TABLE IF NOT EXISTS _migrations (
+      id INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+
+  // Apply pending migrations
+  const applied = _db
+    .query("SELECT id FROM _migrations ORDER BY id")
+    .all() as { id: number }[];
+  const appliedIds = new Set(applied.map((r) => r.id));
+
+  for (const migration of MIGRATIONS) {
+    if (appliedIds.has(migration.id)) continue;
+
+    _db.exec("BEGIN");
+    try {
+      _db.exec(migration.sql);
+      _db.prepare("INSERT INTO _migrations (id, name) VALUES (?, ?)").run(
+        migration.id,
+        migration.name
+      );
+      _db.exec("COMMIT");
+    } catch (error) {
+      _db.exec("ROLLBACK");
+      throw new Error(
+        `Migration ${migration.id} (${migration.name}) failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  return _db;
+}
+
+export function closeDatabase(): void {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+}

package/microservices/microservice-compliance/src/db/migrations.ts

@@ -0,0 +1,63 @@
+export interface MigrationEntry {
+  id: number;
+  name: string;
+  sql: string;
+}
+
+export const MIGRATIONS: MigrationEntry[] = [
+  {
+    id: 1,
+    name: "initial_schema",
+    sql: `
+      CREATE TABLE IF NOT EXISTS requirements (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        framework TEXT CHECK(framework IN ('gdpr','soc2','hipaa','pci','tax','iso27001','custom')),
+        status TEXT NOT NULL DEFAULT 'in_progress' CHECK(status IN ('compliant','non_compliant','in_progress','not_applicable')),
+        description TEXT,
+        evidence TEXT,
+        due_date TEXT,
+        reviewed_at TEXT,
+        reviewer TEXT,
+        metadata TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS licenses (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        type TEXT CHECK(type IN ('software','business','professional','patent','trademark')),
+        issuer TEXT,
+        license_number TEXT,
+        status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active','expired','pending_renewal')),
+        issued_at TEXT,
+        expires_at TEXT,
+        auto_renew INTEGER NOT NULL DEFAULT 0,
+        cost REAL,
+        metadata TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS audits (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        framework TEXT,
+        status TEXT NOT NULL DEFAULT 'scheduled' CHECK(status IN ('scheduled','in_progress','completed','failed')),
+        findings TEXT NOT NULL DEFAULT '[]',
+        auditor TEXT,
+        scheduled_at TEXT,
+        completed_at TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_requirements_framework ON requirements(framework);
+      CREATE INDEX IF NOT EXISTS idx_requirements_status ON requirements(status);
+      CREATE INDEX IF NOT EXISTS idx_requirements_due_date ON requirements(due_date);
+      CREATE INDEX IF NOT EXISTS idx_licenses_status ON licenses(status);
+      CREATE INDEX IF NOT EXISTS idx_licenses_expires_at ON licenses(expires_at);
+      CREATE INDEX IF NOT EXISTS idx_audits_framework ON audits(framework);
+      CREATE INDEX IF NOT EXISTS idx_audits_status ON audits(status);
+    `,
+  },
+];

package/microservices/microservice-compliance/src/index.ts

@@ -0,0 +1,46 @@
+/**
+ * microservice-compliance — Compliance management microservice
+ */
+
+export {
+  createRequirement,
+  getRequirement,
+  listRequirements,
+  updateRequirement,
+  deleteRequirement,
+  searchRequirements,
+  createLicense,
+  getLicense,
+  listLicenses,
+  updateLicense,
+  deleteLicense,
+  renewLicense,
+  listExpiringLicenses,
+  getLicenseStats,
+  scheduleAudit,
+  getAudit,
+  listAudits,
+  completeAudit,
+  getAuditReport,
+  deleteAudit,
+  getComplianceScore,
+  getFrameworkStatus,
+  type Requirement,
+  type License,
+  type Audit,
+  type Framework,
+  type RequirementStatus,
+  type LicenseType,
+  type LicenseStatus,
+  type AuditStatus,
+  type CreateRequirementInput,
+  type UpdateRequirementInput,
+  type ListRequirementsOptions,
+  type CreateLicenseInput,
+  type UpdateLicenseInput,
+  type ListLicensesOptions,
+  type CreateAuditInput,
+  type ListAuditsOptions,
+} from "./db/compliance.js";
+
+export { getDatabase, closeDatabase } from "./db/database.js";

package/microservices/microservice-compliance/src/mcp/index.ts

@@ -0,0 +1,438 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import {
+  createRequirement,
+  getRequirement,
+  listRequirements,
+  updateRequirement,
+  deleteRequirement,
+  searchRequirements,
+  createLicense,
+  getLicense,
+  listLicenses,
+  updateLicense,
+  deleteLicense,
+  renewLicense,
+  listExpiringLicenses,
+  getLicenseStats,
+  scheduleAudit,
+  getAudit,
+  listAudits,
+  completeAudit,
+  getAuditReport,
+  deleteAudit,
+  getComplianceScore,
+  getFrameworkStatus,
+} from "../db/compliance.js";
+
+const server = new McpServer({
+  name: "microservice-compliance",
+  version: "0.0.1",
+});
+
+// --- Requirements ---
+
+server.registerTool(
+  "create_requirement",
+  {
+    title: "Create Requirement",
+    description: "Create a new compliance requirement.",
+    inputSchema: {
+      name: z.string(),
+      framework: z.enum(["gdpr", "soc2", "hipaa", "pci", "tax", "iso27001", "custom"]).optional(),
+      status: z.enum(["compliant", "non_compliant", "in_progress", "not_applicable"]).optional(),
+      description: z.string().optional(),
+      evidence: z.string().optional(),
+      due_date: z.string().optional(),
+      reviewer: z.string().optional(),
+    },
+  },
+  async (params) => {
+    const req = createRequirement(params);
+    return { content: [{ type: "text", text: JSON.stringify(req, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "get_requirement",
+  {
+    title: "Get Requirement",
+    description: "Get a compliance requirement by ID.",
+    inputSchema: { id: z.string() },
+  },
+  async ({ id }) => {
+    const req = getRequirement(id);
+    if (!req) {
+      return { content: [{ type: "text", text: `Requirement '${id}' not found.` }], isError: true };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(req, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "list_requirements",
+  {
+    title: "List Requirements",
+    description: "List compliance requirements with optional filters.",
+    inputSchema: {
+      framework: z.string().optional(),
+      status: z.string().optional(),
+      search: z.string().optional(),
+      limit: z.number().optional(),
+    },
+  },
+  async (params) => {
+    const reqs = listRequirements(params);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ requirements: reqs, count: reqs.length }, null, 2) }],
+    };
+  }
+);
+
+server.registerTool(
+  "update_requirement",
+  {
+    title: "Update Requirement",
+    description: "Update an existing compliance requirement.",
+    inputSchema: {
+      id: z.string(),
+      name: z.string().optional(),
+      framework: z.enum(["gdpr", "soc2", "hipaa", "pci", "tax", "iso27001", "custom"]).optional(),
+      status: z.enum(["compliant", "non_compliant", "in_progress", "not_applicable"]).optional(),
+      description: z.string().optional(),
+      evidence: z.string().optional(),
+      due_date: z.string().optional(),
+      reviewed_at: z.string().optional(),
+      reviewer: z.string().optional(),
+    },
+  },
+  async ({ id, ...input }) => {
+    const req = updateRequirement(id, input);
+    if (!req) {
+      return { content: [{ type: "text", text: `Requirement '${id}' not found.` }], isError: true };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(req, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "delete_requirement",
+  {
+    title: "Delete Requirement",
+    description: "Delete a compliance requirement by ID.",
+    inputSchema: { id: z.string() },
+  },
+  async ({ id }) => {
+    const deleted = deleteRequirement(id);
+    return { content: [{ type: "text", text: JSON.stringify({ id, deleted }) }] };
+  }
+);
+
+server.registerTool(
+  "search_requirements",
+  {
+    title: "Search Requirements",
+    description: "Search requirements by name or description.",
+    inputSchema: { query: z.string() },
+  },
+  async ({ query }) => {
+    const results = searchRequirements(query);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ results, count: results.length }, null, 2) }],
+    };
+  }
+);
+
+// --- Licenses ---
+
+server.registerTool(
+  "create_license",
+  {
+    title: "Create License",
+    description: "Create a new license.",
+    inputSchema: {
+      name: z.string(),
+      type: z.enum(["software", "business", "professional", "patent", "trademark"]).optional(),
+      issuer: z.string().optional(),
+      license_number: z.string().optional(),
+      status: z.enum(["active", "expired", "pending_renewal"]).optional(),
+      issued_at: z.string().optional(),
+      expires_at: z.string().optional(),
+      auto_renew: z.boolean().optional(),
+      cost: z.number().optional(),
+    },
+  },
+  async (params) => {
+    const lic = createLicense(params);
+    return { content: [{ type: "text", text: JSON.stringify(lic, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "get_license",
+  {
+    title: "Get License",
+    description: "Get a license by ID.",
+    inputSchema: { id: z.string() },
+  },
+  async ({ id }) => {
+    const lic = getLicense(id);
+    if (!lic) {
+      return { content: [{ type: "text", text: `License '${id}' not found.` }], isError: true };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(lic, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "list_licenses",
+  {
+    title: "List Licenses",
+    description: "List licenses with optional filters.",
+    inputSchema: {
+      type: z.string().optional(),
+      status: z.string().optional(),
+      search: z.string().optional(),
+      limit: z.number().optional(),
+    },
+  },
+  async (params) => {
+    const lics = listLicenses(params);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ licenses: lics, count: lics.length }, null, 2) }],
+    };
+  }
+);
+
+server.registerTool(
+  "update_license",
+  {
+    title: "Update License",
+    description: "Update an existing license.",
+    inputSchema: {
+      id: z.string(),
+      name: z.string().optional(),
+      type: z.enum(["software", "business", "professional", "patent", "trademark"]).optional(),
+      issuer: z.string().optional(),
+      license_number: z.string().optional(),
+      status: z.enum(["active", "expired", "pending_renewal"]).optional(),
+      issued_at: z.string().optional(),
+      expires_at: z.string().optional(),
+      auto_renew: z.boolean().optional(),
+      cost: z.number().optional(),
+    },
+  },
+  async ({ id, ...input }) => {
+    const lic = updateLicense(id, input);
+    if (!lic) {
+      return { content: [{ type: "text", text: `License '${id}' not found.` }], isError: true };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(lic, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "delete_license",
+  {
+    title: "Delete License",
+    description: "Delete a license by ID.",
+    inputSchema: { id: z.string() },
+  },
+  async ({ id }) => {
+    const deleted = deleteLicense(id);
+    return { content: [{ type: "text", text: JSON.stringify({ id, deleted }) }] };
+  }
+);
+
+server.registerTool(
+  "renew_license",
+  {
+    title: "Renew License",
+    description: "Renew a license with a new expiry date.",
+    inputSchema: {
+      id: z.string(),
+      expires_at: z.string(),
+    },
+  },
+  async ({ id, expires_at }) => {
+    const lic = renewLicense(id, expires_at);
+    if (!lic) {
+      return { content: [{ type: "text", text: `License '${id}' not found.` }], isError: true };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(lic, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "list_expiring_licenses",
+  {
+    title: "List Expiring Licenses",
+    description: "List licenses expiring within N days.",
+    inputSchema: { days: z.number().default(30) },
+  },
+  async ({ days }) => {
+    const lics = listExpiringLicenses(days);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ licenses: lics, count: lics.length }, null, 2) }],
+    };
+  }
+);
+
+server.registerTool(
+  "get_license_stats",
+  {
+    title: "Get License Stats",
+    description: "Get license statistics — totals by status and type.",
+    inputSchema: {},
+  },
+  async () => {
+    const stats = getLicenseStats();
+    return { content: [{ type: "text", text: JSON.stringify(stats, null, 2) }] };
+  }
+);
+
+// --- Audits ---
+
+server.registerTool(
+  "schedule_audit",
+  {
+    title: "Schedule Audit",
+    description: "Schedule a new compliance audit.",
+    inputSchema: {
+      name: z.string(),
+      framework: z.string().optional(),
+      auditor: z.string().optional(),
+      scheduled_at: z.string().optional(),
+    },
+  },
+  async (params) => {
+    const audit = scheduleAudit(params);
+    return { content: [{ type: "text", text: JSON.stringify(audit, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "get_audit",
+  {
+    title: "Get Audit",
+    description: "Get an audit by ID.",
+    inputSchema: { id: z.string() },
+  },
+  async ({ id }) => {
+    const audit = getAudit(id);
+    if (!audit) {
+      return { content: [{ type: "text", text: `Audit '${id}' not found.` }], isError: true };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(audit, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "list_audits",
+  {
+    title: "List Audits",
+    description: "List audits with optional filters.",
+    inputSchema: {
+      framework: z.string().optional(),
+      status: z.string().optional(),
+      limit: z.number().optional(),
+    },
+  },
+  async (params) => {
+    const audits = listAudits(params);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ audits, count: audits.length }, null, 2) }],
+    };
+  }
+);
+
+server.registerTool(
+  "complete_audit",
+  {
+    title: "Complete Audit",
+    description: "Complete an audit with findings. Audits with critical-severity findings are marked as failed.",
+    inputSchema: {
+      id: z.string(),
+      findings: z.array(z.any()),
+    },
+  },
+  async ({ id, findings }) => {
+    const audit = completeAudit(id, findings);
+    if (!audit) {
+      return { content: [{ type: "text", text: `Audit '${id}' not found.` }], isError: true };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(audit, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "get_audit_report",
+  {
+    title: "Get Audit Report",
+    description: "Get a detailed audit report with findings summary.",
+    inputSchema: { id: z.string() },
+  },
+  async ({ id }) => {
+    const report = getAuditReport(id);
+    if (!report) {
+      return { content: [{ type: "text", text: `Audit '${id}' not found.` }], isError: true };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "delete_audit",
+  {
+    title: "Delete Audit",
+    description: "Delete an audit by ID.",
+    inputSchema: { id: z.string() },
+  },
+  async ({ id }) => {
+    const deleted = deleteAudit(id);
+    return { content: [{ type: "text", text: JSON.stringify({ id, deleted }) }] };
+  }
+);
+
+// --- Analytics ---
+
+server.registerTool(
+  "get_compliance_score",
+  {
+    title: "Get Compliance Score",
+    description: "Get the overall compliance score — percentage of applicable requirements that are compliant.",
+    inputSchema: {},
+  },
+  async () => {
+    const score = getComplianceScore();
+    return { content: [{ type: "text", text: JSON.stringify(score, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "get_framework_status",
+  {
+    title: "Get Framework Status",
+    description: "Get compliance status for a specific framework.",
+    inputSchema: { framework: z.string() },
+  },
+  async ({ framework }) => {
+    const status = getFrameworkStatus(framework);
+    return { content: [{ type: "text", text: JSON.stringify(status, null, 2) }] };
+  }
+);
+
+// --- Start ---
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("microservice-compliance MCP server running on stdio");
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/microservices/microservice-habits/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@hasna/microservice-habits",
+  "version": "0.0.1",
+  "description": "Habit tracking microservice with streaks, completions, and analytics",
+  "type": "module",
+  "bin": {
+    "microservice-habits": "./src/cli/index.ts",
+    "microservice-habits-mcp": "./src/mcp/index.ts"
+  },
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "dev": "bun run ./src/cli/index.ts",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "commander": "^12.1.0",
+    "zod": "^3.24.0"
+  },
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  }
+}