@orderful/droid 0.45.0 → 0.46.0

package/dist/tools/pii/skills/pii/scripts/presidio.test.ts

@@ -0,0 +1,444 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { spawnSync } from 'child_process';
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+/**
+ * Integration tests for presidio scripts.
+ *
+ * These tests validate argument parsing, error paths, and JSON output shape.
+ * They do NOT invoke Presidio/Python directly — all Python-dependent paths
+ * are gated by existsSync checks in the scripts, so tests run without Python.
+ */
+
+const SCRIPTS_DIR = __dirname;
+
+interface ScriptResult {
+  success: boolean;
+  already_existed?: boolean;
+  initialized?: boolean;
+  python_path?: string;
+  venv_path?: string;
+  entities?: Array<{ type: string; start: number; end: number; score: number; line: number; text?: string }>;
+  dry_run?: boolean;
+  original_path?: string;
+  output_path?: string;
+  entities_found?: number;
+  entities_redacted?: number;
+  redacted_text?: string;
+  error?: string;
+  init_required?: boolean;
+}
+
+function runScript(scriptName: string, args: string[]): ScriptResult {
+  const scriptPath = join(SCRIPTS_DIR, `${scriptName}.ts`);
+
+  const result = spawnSync('bun', ['run', scriptPath, ...args], {
+    encoding: 'utf-8',
+    cwd: process.cwd(),
+  });
+
+  if (result.error) {
+    return { success: false, error: result.error.message };
+  }
+
+  try {
+    return JSON.parse(result.stdout.trim());
+  } catch {
+    return {
+      success: false,
+      error: `Failed to parse output: ${result.stdout}\nStderr: ${result.stderr}`,
+    };
+  }
+}
+
+function createFakeVenvWithPython(tempHome: string, scriptContent: string): string {
+  const venvPath = join(tempHome, '.droid', 'runtimes', 'presidio');
+  const binDir = join(venvPath, 'bin');
+  mkdirSync(binDir, { recursive: true });
+  writeFileSync(join(binDir, 'python3'), scriptContent, { mode: 0o755 });
+  return venvPath;
+}
+
+// ─── presidio-init ───────────────────────────────────────────────────────────
+
+describe('presidio-init', () => {
+  let tempHome: string;
+  let originalHome: string;
+
+  beforeEach(() => {
+    originalHome = process.env.HOME || '';
+    tempHome = mkdtempSync(join(tmpdir(), 'pii-test-home-'));
+    process.env.HOME = tempHome;
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    try {
+      rmSync(tempHome, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  it('returns already_existed:true when marker file and venv binary both exist', () => {
+    // Pre-create the venv structure
+    const venvPath = join(tempHome, '.droid', 'runtimes', 'presidio');
+    const binDir = join(venvPath, 'bin');
+    mkdirSync(binDir, { recursive: true });
+    writeFileSync(join(venvPath, '.droid-initialized'), new Date().toISOString());
+    writeFileSync(join(binDir, 'python3'), '#!/bin/bash\necho "Python 3.9.0"', { mode: 0o755 });
+
+    const result = spawnSync(
+      'bun',
+      ['run', join(SCRIPTS_DIR, 'presidio-init.ts')],
+      {
+        encoding: 'utf-8',
+        env: { ...process.env, HOME: tempHome },
+      }
+    );
+
+    let parsed: ScriptResult;
+    try {
+      parsed = JSON.parse(result.stdout.trim());
+    } catch {
+      parsed = { success: false, error: `Parse error: ${result.stdout}` };
+    }
+
+    expect(parsed.success).toBe(true);
+    expect(parsed.already_existed).toBe(true);
+  });
+
+  it('returns success:false with clear error when python3 is not available', () => {
+    // Override PATH to have no python3
+    const result = spawnSync(
+      'bun',
+      ['run', join(SCRIPTS_DIR, 'presidio-init.ts')],
+      {
+        encoding: 'utf-8',
+        env: { ...process.env, HOME: tempHome, PATH: '/nonexistent' },
+      }
+    );
+
+    let parsed: ScriptResult;
+    try {
+      parsed = JSON.parse(result.stdout.trim());
+    } catch {
+      // If Python is truly not found, the error may be in stderr
+      parsed = { success: false, error: 'python3 not found' };
+    }
+
+    expect(parsed.success).toBe(false);
+    expect(parsed.error).toBeDefined();
+  });
+});
+
+// ─── presidio-analyze ────────────────────────────────────────────────────────
+
+describe('presidio-analyze', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'pii-analyze-test-'));
+  });
+
+  afterEach(() => {
+    try {
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // Ignore
+    }
+  });
+
+  it('returns success:false with init_required when venv does not exist', () => {
+    const result = spawnSync(
+      'bun',
+      ['run', join(SCRIPTS_DIR, 'presidio-analyze.ts'), '--file', join(tempDir, 'test.md')],
+      {
+        encoding: 'utf-8',
+        env: { ...process.env, HOME: join(tempDir, 'nonexistent-home') },
+      }
+    );
+
+    let parsed: ScriptResult;
+    try {
+      parsed = JSON.parse(result.stdout.trim());
+    } catch {
+      parsed = { success: false, error: `Parse error: ${result.stdout}` };
+    }
+
+    expect(parsed.success).toBe(false);
+    expect(parsed.init_required).toBe(true);
+    expect(parsed.error).toContain('presidio-init');
+  });
+
+  it('returns success:false when neither --file nor --text is provided', () => {
+    // Use a fake home so venv won't be found — still validates arg parsing
+    const result = spawnSync(
+      'bun',
+      ['run', join(SCRIPTS_DIR, 'presidio-analyze.ts')],
+      {
+        encoding: 'utf-8',
+        env: { ...process.env, HOME: join(tempDir, 'nonexistent-home') },
+      }
+    );
+
+    let parsed: ScriptResult;
+    try {
+      parsed = JSON.parse(result.stdout.trim());
+    } catch {
+      parsed = { success: false, error: `Parse error: ${result.stdout}` };
+    }
+
+    // Either init_required or missing arg error — both are valid failures
+    expect(parsed.success).toBe(false);
+    expect(parsed.error).toBeDefined();
+  });
+
+  it('returns success:false when --file does not exist (and venv exists)', () => {
+    // Pre-create a fake venv so the script gets past the venv check
+    const fakeHome = join(tempDir, 'fake-home');
+    createFakeVenvWithPython(fakeHome, '#!/bin/bash\necho ""');
+
+    const nonExistentFile = join(tempDir, 'does-not-exist.md');
+
+    const result = spawnSync(
+      'bun',
+      ['run', join(SCRIPTS_DIR, 'presidio-analyze.ts'), '--file', nonExistentFile],
+      {
+        encoding: 'utf-8',
+        env: { ...process.env, HOME: fakeHome },
+      }
+    );
+
+    let parsed: ScriptResult;
+    try {
+      parsed = JSON.parse(result.stdout.trim());
+    } catch {
+      parsed = { success: false, error: `Parse error: ${result.stdout}` };
+    }
+
+    expect(parsed.success).toBe(false);
+    expect(parsed.error).toContain('not found');
+  });
+
+  it('rejects invalid entity names before invoking Python', () => {
+    const fakeHome = join(tempDir, 'fake-home');
+    createFakeVenvWithPython(fakeHome, '#!/bin/bash\necho \'[]\'');
+
+    const result = spawnSync(
+      'bun',
+      [
+        'run',
+        join(SCRIPTS_DIR, 'presidio-analyze.ts'),
+        '--text',
+        'Call me at 555-1234',
+        '--entities',
+        'EMAIL_ADDRESS,__import__("os").system("whoami")',
+      ],
+      {
+        encoding: 'utf-8',
+        env: { ...process.env, HOME: fakeHome },
+      }
+    );
+
+    const parsed = JSON.parse(result.stdout.trim()) as ScriptResult;
+    expect(parsed.success).toBe(false);
+    expect(parsed.error).toContain('Invalid entity type');
+  });
+
+  it('does not include raw text in analyzer output entities', () => {
+    const fakeHome = join(tempDir, 'fake-home-no-text');
+    createFakeVenvWithPython(
+      fakeHome,
+      `#!/bin/bash
+if grep -q "'text': text\\[r.start:r.end\\]" "$1"; then
+  echo '[{"type":"EMAIL_ADDRESS","start":11,"end":27,"score":0.99,"text":"jane@example.com"}]'
+else
+  echo '[{"type":"EMAIL_ADDRESS","start":11,"end":27,"score":0.99}]'
+fi`,
+    );
+
+    const result = spawnSync(
+      'bun',
+      ['run', join(SCRIPTS_DIR, 'presidio-analyze.ts'), '--text', 'Contact me: jane@example.com'],
+      {
+        encoding: 'utf-8',
+        env: { ...process.env, HOME: fakeHome },
+      }
+    );
+
+    const parsed = JSON.parse(result.stdout.trim()) as ScriptResult;
+    expect(parsed.success).toBe(true);
+    expect(parsed.entities?.[0]?.type).toBe('EMAIL_ADDRESS');
+    expect(parsed.entities?.[0]).not.toHaveProperty('text');
+  });
+});
+
+// ─── presidio-redact ─────────────────────────────────────────────────────────
+
+describe('presidio-redact', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'pii-redact-test-'));
+  });
+
+  afterEach(() => {
+    try {
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // Ignore
+    }
+  });
+
+  it('returns success:false when --file is missing', () => {
+    const result = spawnSync(
+      'bun',
+      ['run', join(SCRIPTS_DIR, 'presidio-redact.ts')],
+      {
+        encoding: 'utf-8',
+        env: { ...process.env, HOME: join(tempDir, 'nonexistent-home') },
+      }
+    );
+
+    let parsed: ScriptResult;
+    try {
+      parsed = JSON.parse(result.stdout.trim());
+    } catch {
+      parsed = { success: false, error: `Parse error: ${result.stdout}` };
+    }
+
+    expect(parsed.success).toBe(false);
+    // Either init_required or missing --file error
+    expect(parsed.error).toBeDefined();
+  });
+
+  it('returns success:false with init_required when venv does not exist', () => {
+    const testFile = join(tempDir, 'test.md');
+    writeFileSync(testFile, 'Hello, my email is test@example.com');
+
+    const result = spawnSync(
+      'bun',
+      ['run', join(SCRIPTS_DIR, 'presidio-redact.ts'), '--file', testFile],
+      {
+        encoding: 'utf-8',
+        env: { ...process.env, HOME: join(tempDir, 'nonexistent-home') },
+      }
+    );
+
+    let parsed: ScriptResult;
+    try {
+      parsed = JSON.parse(result.stdout.trim());
+    } catch {
+      parsed = { success: false, error: `Parse error: ${result.stdout}` };
+    }
+
+    expect(parsed.success).toBe(false);
+    expect(parsed.init_required).toBe(true);
+    expect(parsed.error).toContain('presidio-init');
+  });
+
+  it('does not write output file with --dry-run (venv missing path)', () => {
+    const testFile = join(tempDir, 'test.md');
+    writeFileSync(testFile, 'Hello, my email is test@example.com');
+    const expectedOutput = join(tempDir, 'test-redacted.md');
+
+    const result = spawnSync(
+      'bun',
+      ['run', join(SCRIPTS_DIR, 'presidio-redact.ts'), '--file', testFile, '--dry-run'],
+      {
+        encoding: 'utf-8',
+        env: { ...process.env, HOME: join(tempDir, 'nonexistent-home') },
+      }
+    );
+
+    // With no venv, it will fail before writing
+    expect(existsSync(expectedOutput)).toBe(false);
+
+    let parsed: ScriptResult;
+    try {
+      parsed = JSON.parse(result.stdout.trim());
+    } catch {
+      parsed = { success: false, error: `Parse error: ${result.stdout}` };
+    }
+    expect(parsed.success).toBe(false);
+    expect(parsed.init_required).toBe(true);
+  });
+
+  it('correctly parses --output path argument', () => {
+    const testFile = join(tempDir, 'source.md');
+    writeFileSync(testFile, 'Contact: jane@example.com');
+    const customOutput = join(tempDir, 'custom-output.md');
+
+    // Without venv this will fail, but we can check the argument is parsed
+    const result = spawnSync(
+      'bun',
+      ['run', join(SCRIPTS_DIR, 'presidio-redact.ts'), '--file', testFile, '--output', customOutput],
+      {
+        encoding: 'utf-8',
+        env: { ...process.env, HOME: join(tempDir, 'nonexistent-home') },
+      }
+    );
+
+    let parsed: ScriptResult;
+    try {
+      parsed = JSON.parse(result.stdout.trim());
+    } catch {
+      parsed = { success: false, error: `Parse error: ${result.stdout}` };
+    }
+
+    // With no venv this will fail with init_required
+    expect(parsed.success).toBe(false);
+    expect(parsed.init_required).toBe(true);
+    // Confirm the output file was NOT created
+    expect(existsSync(customOutput)).toBe(false);
+  });
+
+  it('omits redacted_text in non-dry-run output', () => {
+    const fakeHome = join(tempDir, 'fake-home-no-redacted-text');
+    createFakeVenvWithPython(fakeHome, '#!/bin/bash\necho \'{"redacted_text":"masked text","entities_found":1,"entities_redacted":1}\'');
+
+    const testFile = join(tempDir, 'source.md');
+    const outputFile = join(tempDir, 'source-redacted.md');
+    writeFileSync(testFile, 'Contact: jane@example.com');
+
+    const result = spawnSync(
+      'bun',
+      ['run', join(SCRIPTS_DIR, 'presidio-redact.ts'), '--file', testFile],
+      {
+        encoding: 'utf-8',
+        env: { ...process.env, HOME: fakeHome },
+      }
+    );
+
+    const parsed = JSON.parse(result.stdout.trim()) as ScriptResult;
+    expect(parsed.success).toBe(true);
+    expect(parsed.dry_run).toBe(false);
+    expect(parsed.redacted_text).toBeUndefined();
+    expect(parsed.output_path).toBe(outputFile);
+    expect(existsSync(outputFile)).toBe(true);
+  });
+
+  it('rejects unsupported entity names', () => {
+    const fakeHome = join(tempDir, 'fake-home');
+    createFakeVenvWithPython(fakeHome, '#!/bin/bash\necho \'{"redacted_text":"ok","entities_found":0,"entities_redacted":0}\'');
+
+    const testFile = join(tempDir, 'source.md');
+    writeFileSync(testFile, 'Contact: jane@example.com');
+
+    const result = spawnSync(
+      'bun',
+      ['run', join(SCRIPTS_DIR, 'presidio-redact.ts'), '--file', testFile, '--entities', 'NOT_A_REAL_ENTITY'],
+      {
+        encoding: 'utf-8',
+        env: { ...process.env, HOME: fakeHome },
+      }
+    );
+
+    const parsed = JSON.parse(result.stdout.trim()) as ScriptResult;
+    expect(parsed.success).toBe(false);
+    expect(parsed.error).toContain('Unsupported entity type');
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orderful/droid",
-  "version": "0.45.0",
+  "version": "0.46.0",
   "description": "AI workflow toolkit for sharing skills, commands, and agents across the team",
   "type": "module",
   "bin": {

package/src/tools/droid/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "droid",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Core droid meta-skill for update awareness, tool discovery, and usage help. Checks for updates, helps users find tools, and answers 'how do I...' questions about droid workflows.",
   "author": {
     "name": "Orderful",

package/src/tools/droid/TOOL.yaml

@@ -1,6 +1,6 @@
 name: droid
 description: "Core droid meta-skill for update awareness, tool discovery, and usage help. Checks for updates, helps users find tools, and answers 'how do I...' questions about droid workflows."
-version: 0.7.0
+version: 0.7.1
 status: beta
 
 # System tool - always stays current regardless of auto-update settings

package/src/tools/droid/skills/droid/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: droid
 description: "Core droid meta-skill for updates, tool discovery, usage help, and skill overrides. Use when checking for droid updates, discovering available tools, answering 'how do I...' questions about droid workflows, or customizing skill behaviour. User prompts like 'any droid updates?', 'what tools do I have?', 'what tools do you have?', 'remind me what tools you have', 'hey droid what can you do', 'how do I add context?', 'remind me how to use codex', 'what's the best way to start a session?', 'customize brain search', 'create an override for brain'."
+alwaysApply: true
 allowed-tools: [Bash, Read, Write]
 ---
 

package/src/tools/droid/skills/droid-bootstrap/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: droid-bootstrap
 description: "Lightweight droid bootstrap for update awareness. Checks for droid updates once per session."
+alwaysApply: true
 allowed-tools: [Bash]
 ---
 

package/src/tools/edi-schema/.claude-plugin/plugin.json

@@ -0,0 +1,25 @@
+{
+  "name": "droid-edi-schema",
+  "version": "0.1.0",
+  "description": "Query EDI schemas without context overhead. Uses a sub-agent to inspect large schema and code-list files, then returns concise results.",
+  "author": {
+    "name": "Orderful",
+    "url": "https://github.com/orderful"
+  },
+  "repository": "https://github.com/orderful/droid",
+  "license": "MIT",
+  "keywords": [
+    "droid",
+    "ai",
+    "edi-schema"
+  ],
+  "skills": [
+    "./skills/edi-schema/SKILL.md"
+  ],
+  "commands": [
+    "./commands/edi-schema.md"
+  ],
+  "agents": [
+    "./agents/edi-schema-agent.md"
+  ]
+}

package/src/tools/edi-schema/TOOL.yaml

@@ -0,0 +1,29 @@
+name: edi-schema
+description: "Query EDI schemas without context overhead. Uses a sub-agent to inspect large schema and code-list files, then returns concise results."
+version: 0.1.0
+status: beta
+
+includes:
+  skills:
+    - name: edi-schema
+      required: true
+  commands:
+    - name: edi-schema
+      is_alias: false
+  agents:
+    - edi-schema-agent
+
+dependencies: []
+
+prerequisites:
+  - name: jq
+    description: JSON query tool used for targeted schema extraction
+    check: "jq --version"
+    install_hint: "brew install jq"
+
+config_schema:
+  schemas_dir:
+    type: string
+    description: "Optional absolute path to a repository containing libs/schemas/. If empty, auto-detect from current workspace."
+    required: false
+    default: ""

package/src/tools/edi-schema/agents/edi-schema-agent.md

@@ -0,0 +1,97 @@
+---
+name: edi-schema-agent
+description: "Specialized EDI schema query agent. Uses jq and targeted reads to extract precise schema details with minimal output."
+tools:
+  - Read
+  - Glob
+  - Grep
+  - Bash
+color: blue
+---
+
+You are an EDI schema analysis agent. Your job is to query large schema files and return concise, accurate findings.
+
+## Inputs
+
+You will receive:
+
+1. `schemasRoot`: Absolute repo path containing `libs/schemas/src/lib/data`
+2. `mode`: One of `field-search`, `segments`, `loops`, `codes`, `versions`, `types`
+3. `transactionType`: Full or short transaction type identifier
+4. `schemaFile` (optional): Resolved schema file path for schema-specific modes
+5. `query` (optional): Search text for `field-search`
+6. `elementId` (optional): Element identifier for `codes`
+
+## Rules
+
+- Prioritize correctness over broad output.
+- Never output full JSON blobs.
+- Keep returned content compact and actionable.
+- Prefer jq for extraction. If jq is missing, use `rg` + targeted reads.
+
+## Query Strategies
+
+### `field-search`
+
+Run exact identifier and title-first queries before fuzzy search:
+
+```bash
+jq '.. | objects | select(.elementIdentifier? == $id)' --arg id "{query}" "{schemaFile}"
+jq '.. | objects | select(.title? == $title)' --arg title "{query}" "{schemaFile}"
+jq '.. | objects | select(.title? | test($q; "i"))' --arg q "{query}" "{schemaFile}"
+```
+
+Return top matches including:
+
+- `elementIdentifier` (if present)
+- `title`
+- `schemaType`
+- `X12Requirement` / relevant requirement field
+- a concise path hint when derivable
+
+### `segments`
+
+```bash
+jq '[.. | objects | select(.schemaType? == "segmentInstance") | {title, requirement: .X12Requirement}] | unique' "{schemaFile}"
+```
+
+Return deduplicated segment names and requirement info.
+
+### `loops`
+
+```bash
+jq '[.. | objects | select(.schemaType? | test("loop")) | {title, schemaType}]' "{schemaFile}"
+```
+
+Return loop hierarchy summary. Include parent-child nesting hints if visible.
+
+### `codes`
+
+Find likely code-list file (for example `x12_004010_codeList.json`), then:
+
+```bash
+jq --arg id "{elementId}" '.[$id]' "{codeListFile}"
+```
+
+Return code values and descriptions. If no entry exists, return "not found" and suggest checking identifier/version.
+
+### `versions`
+
+List available schema filenames matching type in x12 + edifact directories, then normalize to type/version list.
+
+### `types`
+
+Read `transactionTypes.json` and return a concise sorted list (or filtered list if query provided).
+
+## Output Format
+
+Respond in markdown with this structure:
+
+1. `Resolved:` line (type/version and file used)
+2. `Results:` compact bullets or table
+3. `Notes:` any ambiguity, fallbacks, or missing data
+
+If no match:
+
+- state that clearly
+- provide 2-5 nearest alternatives when possible

package/src/tools/edi-schema/commands/edi-schema.md

@@ -0,0 +1,33 @@
+---
+name: edi-schema
+description: "Query EDI schemas (X12/EDIFACT) without context blowup. Find fields, segments, loops, and code-list values."
+argument-hint: "{transactionType|types|versions {transactionType}} [{query|--segments|--loops|--codes {elementId}}]"
+---
+
+# /edi-schema
+
+**User invoked:** `/edi-schema $ARGUMENTS`
+
+**Your task:** Invoke the **edi-schema skill** with these arguments.
+
+## Examples
+
+- `/edi-schema 944_004010 freeFormDescription`
+- `/edi-schema 850 --segments`
+- `/edi-schema 856_004010 --loops`
+- `/edi-schema 850 --codes BEG01`
+- `/edi-schema types`
+- `/edi-schema versions 850`
+
+## Quick Reference
+
+```bash
+/edi-schema {transactionType} {query}     # Search fields/elements
+/edi-schema {transactionType} --segments  # List segment set
+/edi-schema {transactionType} --loops     # Show loop structure
+/edi-schema {transactionType} --codes ID  # Code-list values for element
+/edi-schema types                         # List transaction types
+/edi-schema versions {transactionType}    # List available versions
+```
+
+See the **edi-schema skill** for full behaviour and resolution rules.