@tpmjs/official-policy-doc-format 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2025 TPMJS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+import * as ai from 'ai';
+
+/**
+ * Policy Document Format Tool for TPMJS
+ * Formats HR policy content into standardized policy document structure
+ */
+/**
+ * Policy metadata
+ */
+interface PolicyMetadata {
+    title?: string;
+    policyNumber?: string;
+    owner?: string;
+    department?: string;
+    effectiveDate?: string;
+    reviewDate?: string;
+    version?: string;
+    approvedBy?: string;
+}
+/**
+ * Input interface for policy document formatting
+ */
+interface PolicyDocFormatInput {
+    policyContent: string;
+    metadata?: PolicyMetadata;
+}
+/**
+ * Formatted policy document structure
+ */
+interface PolicyDocument {
+    header: {
+        title: string;
+        policyNumber?: string;
+        version: string;
+        effectiveDate: string;
+        reviewDate: string;
+        owner: string;
+        approvedBy?: string;
+    };
+    purpose: string;
+    scope: string;
+    policyStatement: string;
+    procedures: string[];
+    responsibilities: Record<string, string[]>;
+    definitions?: Record<string, string>;
+    relatedPolicies?: string[];
+    enforcement?: string;
+    revisionHistory?: Array<{
+        version: string;
+        date: string;
+        changes: string;
+    }>;
+    fullDocument: string;
+}
+/**
+ * Policy Document Format Tool
+ * Formats HR policy content into standardized policy document structure
+ */
+declare const policyDocFormatTool: ai.Tool<PolicyDocFormatInput, PolicyDocument>;
+
+export { type PolicyDocument, policyDocFormatTool as default, policyDocFormatTool };

package/dist/index.js

@@ -0,0 +1,296 @@
+import { tool, jsonSchema } from 'ai';
+
+// src/index.ts
+var policyDocFormatTool = tool({
+  description: "Formats HR policy content into a standardized policy document structure. Creates organized sections including purpose, scope, policy statement, procedures, responsibilities, and metadata with effective date, owner, and review date.",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      policyContent: {
+        type: "string",
+        description: "Raw policy content to be formatted into standard structure",
+        minLength: 10
+      },
+      metadata: {
+        type: "object",
+        properties: {
+          title: { type: "string", description: "Policy title" },
+          policyNumber: { type: "string", description: "Policy number or identifier" },
+          owner: { type: "string", description: "Policy owner (name or department)" },
+          department: { type: "string", description: "Responsible department" },
+          effectiveDate: { type: "string", description: "Policy effective date" },
+          reviewDate: { type: "string", description: "Next review date" },
+          version: { type: "string", description: "Policy version" },
+          approvedBy: { type: "string", description: "Approver name or title" }
+        },
+        description: "Policy metadata and administrative information"
+      }
+    },
+    required: ["policyContent"],
+    additionalProperties: false
+  }),
+  execute: async ({ policyContent, metadata = {} }) => {
+    if (!policyContent || typeof policyContent !== "string" || policyContent.trim().length < 10) {
+      throw new Error("Policy content must be a non-empty string with at least 10 characters");
+    }
+    try {
+      const title = metadata.title || extractTitle(policyContent) || "Human Resources Policy";
+      const today = /* @__PURE__ */ new Date();
+      const effectiveDate = metadata.effectiveDate || today.toLocaleDateString("en-US", {
+        year: "numeric",
+        month: "long",
+        day: "numeric"
+      });
+      const nextYear = new Date(today);
+      nextYear.setFullYear(today.getFullYear() + 1);
+      const reviewDate = metadata.reviewDate || nextYear.toLocaleDateString("en-US", {
+        year: "numeric",
+        month: "long",
+        day: "numeric"
+      });
+      const header = {
+        title,
+        policyNumber: metadata.policyNumber,
+        version: metadata.version || "1.0",
+        effectiveDate,
+        reviewDate,
+        owner: metadata.owner || metadata.department || "Human Resources",
+        approvedBy: metadata.approvedBy
+      };
+      const purpose = extractPurpose(policyContent);
+      const scope = extractScope(policyContent);
+      const policyStatement = extractPolicyStatement(policyContent);
+      const procedures = extractProcedures(policyContent);
+      const responsibilities = extractResponsibilities(policyContent);
+      const definitions = extractDefinitions(policyContent);
+      const relatedPolicies = extractRelatedPolicies(policyContent);
+      const enforcement = extractEnforcement(policyContent);
+      const fullDocument = buildFullDocument(
+        header,
+        purpose,
+        scope,
+        policyStatement,
+        procedures,
+        responsibilities,
+        definitions,
+        relatedPolicies,
+        enforcement
+      );
+      return {
+        header,
+        purpose,
+        scope,
+        policyStatement,
+        procedures,
+        responsibilities,
+        definitions: definitions.size > 0 ? Object.fromEntries(definitions) : void 0,
+        relatedPolicies: relatedPolicies.length > 0 ? relatedPolicies : void 0,
+        enforcement,
+        revisionHistory: [
+          {
+            version: header.version,
+            date: effectiveDate,
+            changes: "Initial version"
+          }
+        ],
+        fullDocument
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to format policy document: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+});
+function extractTitle(content) {
+  const lines = content.split("\n").filter((l) => l.trim());
+  if (lines.length > 0 && lines[0]) {
+    const firstLine = lines[0].trim();
+    if (firstLine.length < 100 && !firstLine.includes(".")) {
+      return firstLine.replace(/^#+\s*/, "");
+    }
+  }
+  return null;
+}
+function extractPurpose(content) {
+  const purposeMatch = content.match(
+    /(?:purpose|objective|intent)[\s:]+(.+?)(?=\n\n|scope|policy|$)/is
+  );
+  if (purposeMatch && purposeMatch[1]) {
+    return purposeMatch[1].trim();
+  }
+  return "This policy establishes guidelines and procedures to ensure consistency, compliance, and best practices within the organization.";
+}
+function extractScope(content) {
+  const scopeMatch = content.match(/scope[\s:]+(.+?)(?=\n\n|policy|procedure|$)/is);
+  if (scopeMatch && scopeMatch[1]) {
+    return scopeMatch[1].trim();
+  }
+  return "This policy applies to all employees, contractors, and other personnel associated with the organization.";
+}
+function extractPolicyStatement(content) {
+  const statementMatch = content.match(/policy[\s:]+(.+?)(?=\n\n|procedure|$)/is);
+  if (statementMatch && statementMatch[1]) {
+    return statementMatch[1].trim();
+  }
+  const paragraphs = content.split("\n\n").filter((p) => p.trim().length > 50);
+  return paragraphs[0] || content.substring(0, 500);
+}
+function extractProcedures(content) {
+  const procedures = [];
+  const procedureSection = content.match(/procedure[s]?[\s:]+(.+?)(?=\n\n[A-Z]|$)/is);
+  if (procedureSection && procedureSection[1]) {
+    const text = procedureSection[1];
+    const matches = text.match(/(?:^|\n)\s*(?:\d+\.|[-*])\s*(.+)/gm);
+    if (matches) {
+      procedures.push(...matches.map((m) => m.replace(/^\s*(?:\d+\.|[-*])\s*/, "").trim()));
+    }
+  }
+  if (procedures.length === 0) {
+    procedures.push(
+      "Review and understand this policy",
+      "Follow established guidelines and procedures",
+      "Report violations or concerns to management",
+      "Participate in required training"
+    );
+  }
+  return procedures;
+}
+function extractResponsibilities(content) {
+  const responsibilities = {};
+  const respMatch = content.match(/responsibilit(?:ies|y)[\s:]+(.+?)(?=\n\n[A-Z]|$)/is);
+  if (respMatch && respMatch[1]) {
+    const text = respMatch[1];
+    const roleMatches = text.matchAll(/([A-Za-z\s]+?)[:]\s*(.+?)(?=\n[A-Z]|$)/gs);
+    for (const match of roleMatches) {
+      const role = match[1]?.trim();
+      const dutiesText = match[2];
+      if (role && dutiesText) {
+        const duties = dutiesText.split(/[;,]|(?:\n\s*[-*])/g).map((d) => d.trim()).filter((d) => d.length > 0);
+        responsibilities[role] = duties;
+      }
+    }
+  }
+  if (Object.keys(responsibilities).length === 0) {
+    responsibilities["Employees"] = [
+      "Comply with policy requirements",
+      "Report violations or concerns"
+    ];
+    responsibilities["Managers"] = [
+      "Ensure team compliance",
+      "Address policy violations",
+      "Provide guidance and support"
+    ];
+    responsibilities["HR Department"] = [
+      "Maintain and update policy",
+      "Provide training and resources",
+      "Monitor compliance"
+    ];
+  }
+  return responsibilities;
+}
+function extractDefinitions(content) {
+  const definitions = /* @__PURE__ */ new Map();
+  const defMatch = content.match(/definition[s]?[\s:]+(.+?)(?=\n\n[A-Z]|$)/is);
+  if (defMatch && defMatch[1]) {
+    const text = defMatch[1];
+    const termMatches = text.matchAll(/([A-Za-z\s]+?)[:]\s*(.+?)(?=\n|$)/g);
+    for (const match of termMatches) {
+      const term = match[1]?.trim();
+      const definition = match[2]?.trim();
+      if (term && definition) {
+        definitions.set(term, definition);
+      }
+    }
+  }
+  return definitions;
+}
+function extractRelatedPolicies(content) {
+  const policies = [];
+  const relatedMatch = content.match(/related\s+polic(?:ies|y)[\s:]+(.+?)(?=\n\n|$)/is);
+  if (relatedMatch && relatedMatch[1]) {
+    const text = relatedMatch[1];
+    const policyMatches = text.match(/(?:^|\n)\s*(?:\d+\.|[-*])\s*(.+)/gm);
+    if (policyMatches) {
+      policies.push(...policyMatches.map((m) => m.replace(/^\s*(?:\d+\.|[-*])\s*/, "").trim()));
+    }
+  }
+  return policies;
+}
+function extractEnforcement(content) {
+  const enforcementMatch = content.match(/enforcement|violation[s]?[\s:]+(.+?)(?=\n\n|$)/is);
+  if (enforcementMatch && enforcementMatch[1]) {
+    return enforcementMatch[1].trim();
+  }
+  return "Violations of this policy may result in disciplinary action up to and including termination of employment. The severity of disciplinary action will depend on the nature and circumstances of the violation.";
+}
+function buildFullDocument(header, purpose, scope, policyStatement, procedures, responsibilities, definitions, relatedPolicies, enforcement) {
+  const sections = [];
+  sections.push("\u2550".repeat(80));
+  sections.push(header.title.toUpperCase());
+  sections.push("\u2550".repeat(80));
+  sections.push("");
+  if (header.policyNumber) sections.push(`Policy Number: ${header.policyNumber}`);
+  sections.push(`Version: ${header.version}`);
+  sections.push(`Effective Date: ${header.effectiveDate}`);
+  sections.push(`Review Date: ${header.reviewDate}`);
+  sections.push(`Owner: ${header.owner}`);
+  if (header.approvedBy) sections.push(`Approved By: ${header.approvedBy}`);
+  sections.push("");
+  sections.push("1. PURPOSE");
+  sections.push("\u2500".repeat(80));
+  sections.push(purpose);
+  sections.push("");
+  sections.push("2. SCOPE");
+  sections.push("\u2500".repeat(80));
+  sections.push(scope);
+  sections.push("");
+  sections.push("3. POLICY STATEMENT");
+  sections.push("\u2500".repeat(80));
+  sections.push(policyStatement);
+  sections.push("");
+  sections.push("4. PROCEDURES");
+  sections.push("\u2500".repeat(80));
+  procedures.forEach((proc, idx) => {
+    sections.push(`${idx + 1}. ${proc}`);
+  });
+  sections.push("");
+  sections.push("5. RESPONSIBILITIES");
+  sections.push("\u2500".repeat(80));
+  for (const [role, duties] of Object.entries(responsibilities)) {
+    sections.push(`${role}:`);
+    duties.forEach((duty) => {
+      sections.push(`  \u2022 ${duty}`);
+    });
+    sections.push("");
+  }
+  if (definitions && definitions.size > 0) {
+    sections.push("6. DEFINITIONS");
+    sections.push("\u2500".repeat(80));
+    for (const [term, definition] of definitions) {
+      sections.push(`${term}: ${definition}`);
+    }
+    sections.push("");
+  }
+  if (relatedPolicies && relatedPolicies.length > 0) {
+    sections.push("7. RELATED POLICIES");
+    sections.push("\u2500".repeat(80));
+    relatedPolicies.forEach((policy) => {
+      sections.push(`\u2022 ${policy}`);
+    });
+    sections.push("");
+  }
+  if (enforcement) {
+    sections.push("8. ENFORCEMENT");
+    sections.push("\u2500".repeat(80));
+    sections.push(enforcement);
+    sections.push("");
+  }
+  sections.push("\u2550".repeat(80));
+  sections.push("END OF POLICY DOCUMENT");
+  sections.push("\u2550".repeat(80));
+  return sections.join("\n");
+}
+var index_default = policyDocFormatTool;
+
+export { index_default as default, policyDocFormatTool };

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@tpmjs/official-policy-doc-format",
+  "version": "0.1.0",
+  "description": "Formats HR policy content into standardized policy document structure",
+  "type": "module",
+  "keywords": [
+    "tpmjs",
+    "hr",
+    "policy",
+    "documentation",
+    "compliance"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.9.3",
+    "@tpmjs/tsconfig": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anthropics/tpmjs.git",
+    "directory": "packages/tools/official/policy-doc-format"
+  },
+  "homepage": "https://tpmjs.com",
+  "license": "MIT",
+  "tpmjs": {
+    "category": "hr",
+    "frameworks": [
+      "vercel-ai"
+    ],
+    "tools": [
+      {
+        "name": "policyDocFormatTool",
+        "description": "Formats HR policy content into standardized policy document structure",
+        "parameters": [
+          {
+            "name": "policyContent",
+            "type": "string",
+            "description": "Raw policy content to format",
+            "required": true
+          },
+          {
+            "name": "metadata",
+            "type": "object",
+            "description": "Policy metadata (title, owner, dates)",
+            "required": false
+          }
+        ],
+        "returns": {
+          "type": "PolicyDocument",
+          "description": "Formatted policy document with standard structure"
+        }
+      }
+    ]
+  },
+  "dependencies": {
+    "ai": "6.0.0-beta.124"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist .turbo"
+  }
+}