@studio-foundation/cli 0.3.0-beta.1

package/tests/utils/input-wizard.test.ts

@@ -0,0 +1,153 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { InputSchema } from '@studio-foundation/contracts';
+import { collectStructuredInput } from '../../src/utils/input-wizard.js';
+
+// Mock @inquirer/prompts at module level
+vi.mock('@inquirer/prompts', () => ({
+  input: vi.fn(),
+}));
+import { validateInputSchema } from '../../src/utils/input-wizard.js';
+
+describe('validateInputSchema', () => {
+  it('accepts a valid text field', () => {
+    const result = validateInputSchema({
+      type: 'structured',
+      fields: [{ name: 'brief_summary', type: 'text', prompt: 'Brief summary', required: true }],
+    });
+    expect(result.fields).toHaveLength(1);
+    expect(result.fields[0].name).toBe('brief_summary');
+  });
+
+  it('accepts a valid array field', () => {
+    const result = validateInputSchema({
+      type: 'structured',
+      fields: [{ name: 'criteria', type: 'array', items: 'text', prompt: 'Criteria', required: true }],
+    });
+    expect(result.fields[0].type).toBe('array');
+  });
+
+  it('accepts an optional field with a default', () => {
+    const result = validateInputSchema({
+      type: 'structured',
+      fields: [{ name: 'page', type: 'text', prompt: 'Target page', required: false, default: 'src/index.ts' }],
+    });
+    expect(result.fields[0].default).toBe('src/index.ts');
+  });
+
+  it('throws when fields is missing', () => {
+    expect(() => validateInputSchema({ type: 'structured' })).toThrow(
+      'input_schema must have at least one field'
+    );
+  });
+
+  it('throws when fields is empty', () => {
+    expect(() => validateInputSchema({ type: 'structured', fields: [] })).toThrow(
+      'input_schema must have at least one field'
+    );
+  });
+
+  it('throws when a field is missing prompt', () => {
+    expect(() =>
+      validateInputSchema({
+        type: 'structured',
+        fields: [{ name: 'foo', type: 'text', required: true }],
+      })
+    ).toThrow("Field 'foo' must have a non-empty 'prompt'");
+  });
+
+  it('throws when a field has empty prompt', () => {
+    expect(() =>
+      validateInputSchema({
+        type: 'structured',
+        fields: [{ name: 'foo', type: 'text', prompt: '  ', required: true }],
+      })
+    ).toThrow("Field 'foo' must have a non-empty 'prompt'");
+  });
+
+  it('throws when a field has invalid type', () => {
+    expect(() =>
+      validateInputSchema({
+        type: 'structured',
+        fields: [{ name: 'foo', type: 'number', prompt: 'Foo', required: true }],
+      })
+    ).toThrow("Field 'foo' has invalid type 'number'. Must be 'text' or 'array'");
+  });
+
+  it('throws when an array field is missing items', () => {
+    expect(() =>
+      validateInputSchema({
+        type: 'structured',
+        fields: [{ name: 'foo', type: 'array', prompt: 'Foo', required: true }],
+      })
+    ).toThrow("Array field 'foo' must have items: 'text'");
+  });
+
+  it('throws when an array field has non-text items', () => {
+    expect(() =>
+      validateInputSchema({
+        type: 'structured',
+        fields: [{ name: 'foo', type: 'array', items: 'number', prompt: 'Foo', required: true }],
+      })
+    ).toThrow("Array field 'foo' must have items: 'text'");
+  });
+});
+
+describe('collectStructuredInput', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('collects a single text field', async () => {
+    const { input: mockInput } = await import('@inquirer/prompts');
+    (mockInput as ReturnType<typeof vi.fn>).mockResolvedValueOnce('Add dark mode');
+
+    const schema: InputSchema = {
+      type: 'structured',
+      fields: [{ name: 'brief_summary', type: 'text', prompt: 'Brief summary', required: true }],
+    };
+
+    const result = await collectStructuredInput(schema);
+
+    expect(result).toEqual({ brief_summary: 'Add dark mode' });
+    expect(mockInput).toHaveBeenCalledWith(
+      expect.objectContaining({ message: 'Brief summary' })
+    );
+  });
+
+  it('collects an array field with multiple entries', async () => {
+    const { input: mockInput } = await import('@inquirer/prompts');
+    (mockInput as ReturnType<typeof vi.fn>)
+      .mockResolvedValueOnce('First criterion')
+      .mockResolvedValueOnce('Second criterion')
+      .mockResolvedValueOnce('');  // empty → stop
+
+    const schema: InputSchema = {
+      type: 'structured',
+      fields: [{ name: 'criteria', type: 'array', items: 'text', prompt: 'Criteria', required: true }],
+    };
+
+    const result = await collectStructuredInput(schema);
+
+    expect(result).toEqual({ criteria: ['First criterion', 'Second criterion'] });
+  });
+
+  it('collects multiple fields', async () => {
+    const { input: mockInput } = await import('@inquirer/prompts');
+    (mockInput as ReturnType<typeof vi.fn>)
+      .mockResolvedValueOnce('Add dark mode')   // text field
+      .mockResolvedValueOnce('Must work')        // array entry 1
+      .mockResolvedValueOnce('');                // array stop
+
+    const schema: InputSchema = {
+      type: 'structured',
+      fields: [
+        { name: 'summary', type: 'text', prompt: 'Summary', required: true },
+        { name: 'criteria', type: 'array', items: 'text', prompt: 'Criteria', required: true },
+      ],
+    };
+
+    const result = await collectStructuredInput(schema);
+
+    expect(result).toEqual({ summary: 'Add dark mode', criteria: ['Must work'] });
+  });
+});

package/tests/utils/placeholders.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { applyPlaceholders } from '../../src/utils/placeholders.js';
+
+describe('applyPlaceholders', () => {
+  it('replaces a single known placeholder', () => {
+    expect(applyPlaceholders('Hello {{PROJECT_NAME}}', { PROJECT_NAME: 'my-app' }))
+      .toBe('Hello my-app');
+  });
+
+  it('replaces multiple placeholders in one pass', () => {
+    const result = applyPlaceholders(
+      'name: {{PROJECT_NAME}}\ntemplate: {{TEMPLATE_NAME}}\nyear: {{YEAR}}',
+      { PROJECT_NAME: 'x', TEMPLATE_NAME: 'software', YEAR: '2026' }
+    );
+    expect(result).toBe('name: x\ntemplate: software\nyear: 2026');
+  });
+
+  it('replaces the same placeholder multiple times', () => {
+    expect(applyPlaceholders('{{PROJECT_NAME}} / {{PROJECT_NAME}}', { PROJECT_NAME: 'app' }))
+      .toBe('app / app');
+  });
+
+  it('throws on unresolved placeholder', () => {
+    expect(() => applyPlaceholders('{{UNKNOWN}}', {}))
+      .toThrow('Unresolved placeholder: {{UNKNOWN}}');
+  });
+
+  it('returns content unchanged when no placeholders', () => {
+    expect(applyPlaceholders('no placeholders here', {})).toBe('no placeholders here');
+  });
+
+  it('does not replace lowercase or mixed-case patterns', () => {
+    // Only {{ALL_CAPS_WITH_UNDERSCORES}} are treated as placeholders
+    expect(applyPlaceholders('{{lowercase}}', {})).toBe('{{lowercase}}');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vitest.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from 'vitest/config';
+import { resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+
+// Use a stub only when @studio/runner has not been built (e.g. a fresh git worktree).
+// When dist/ exists (CI, main checkout) the real package is used so that transitive
+// imports from other packages (e.g. @studio/api) continue to resolve correctly.
+const runnerDist = resolve(import.meta.dirname, '../runner/dist/index.js');
+const runnerAlias = existsSync(runnerDist) ? {} : {
+  '@studio-foundation/runner': resolve(import.meta.dirname, 'tests/__stubs__/studio-runner.ts'),
+};
+
+export default defineConfig({
+  resolve: {
+    alias: runnerAlias,
+  },
+  test: {
+    include: ['tests/**/*.test.ts'],
+  },
+});