wogiflow 1.0.0

package/scripts/hooks/entry/claude-code/post-tool-use.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Claude Code PostToolUse Hook
+ *
+ * Called after Edit/Write tool execution.
+ * Runs validation (lint, typecheck) on modified files.
+ */
+
+const { runValidation } = require('../../core/validation');
+const { claudeCodeAdapter } = require('../../adapters/claude-code');
+
+async function main() {
+  try {
+    // Read input from stdin
+    let inputData = '';
+    for await (const chunk of process.stdin) {
+      inputData += chunk;
+    }
+
+    const input = inputData ? JSON.parse(inputData) : {};
+    const parsedInput = claudeCodeAdapter.parseInput(input);
+
+    const toolName = parsedInput.toolName;
+    const toolInput = parsedInput.toolInput || {};
+    const toolResponse = parsedInput.toolResponse;
+    const filePath = toolInput.file_path;
+
+    // Only run validation for Edit/Write
+    if (toolName !== 'Edit' && toolName !== 'Write') {
+      console.log(JSON.stringify({ continue: true }));
+      process.exit(0);
+      return;
+    }
+
+    // Skip if tool failed
+    if (toolResponse && toolResponse.error) {
+      console.log(JSON.stringify({ continue: true }));
+      process.exit(0);
+      return;
+    }
+
+    // Run validation
+    const coreResult = await runValidation({
+      filePath,
+      timeout: 30000
+    });
+
+    // Transform to Claude Code format
+    const output = claudeCodeAdapter.transformResult('PostToolUse', coreResult);
+
+    // Output JSON
+    console.log(JSON.stringify(output));
+    process.exit(0);
+  } catch (err) {
+    // Non-blocking error
+    console.error(`[Wogi Flow Hook Error] ${err.message}`);
+    console.log(JSON.stringify({ continue: true }));
+    process.exit(0);
+  }
+}
+
+// Handle stdin properly
+process.stdin.setEncoding('utf8');
+main();

package/scripts/hooks/entry/claude-code/pre-tool-use.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Claude Code PreToolUse Hook
+ *
+ * Called before Edit/Write tool execution.
+ * Enforces task gating and component reuse checking.
+ */
+
+const { checkTaskGate } = require('../../core/task-gate');
+const { checkComponentReuse } = require('../../core/component-check');
+const { claudeCodeAdapter } = require('../../adapters/claude-code');
+
+async function main() {
+  try {
+    // Read input from stdin
+    let inputData = '';
+    for await (const chunk of process.stdin) {
+      inputData += chunk;
+    }
+
+    const input = inputData ? JSON.parse(inputData) : {};
+    const parsedInput = claudeCodeAdapter.parseInput(input);
+
+    const toolName = parsedInput.toolName;
+    const toolInput = parsedInput.toolInput || {};
+    const filePath = toolInput.file_path;
+
+    let coreResult = { allowed: true, blocked: false };
+
+    // Task gating check (for Edit and Write)
+    if (toolName === 'Edit' || toolName === 'Write') {
+      coreResult = checkTaskGate({
+        filePath,
+        operation: toolName.toLowerCase()
+      });
+
+      // If blocked by task gating, return early
+      if (coreResult.blocked) {
+        const output = claudeCodeAdapter.transformResult('PreToolUse', coreResult);
+        console.log(JSON.stringify(output));
+        process.exit(0);
+        return;
+      }
+    }
+
+    // Component reuse check (for Write only)
+    if (toolName === 'Write' && filePath) {
+      const componentResult = checkComponentReuse({
+        filePath,
+        content: toolInput.content
+      });
+
+      // Merge results - component check can add warning or block
+      if (componentResult.blocked || componentResult.warning) {
+        coreResult = {
+          ...coreResult,
+          ...componentResult,
+          // Preserve task gating allowance unless component check blocks
+          allowed: !componentResult.blocked,
+          blocked: componentResult.blocked
+        };
+      }
+    }
+
+    // Transform to Claude Code format
+    const output = claudeCodeAdapter.transformResult('PreToolUse', coreResult);
+
+    // Output JSON
+    console.log(JSON.stringify(output));
+    process.exit(0);
+  } catch (err) {
+    // Non-blocking error - allow operation to continue
+    console.error(`[Wogi Flow Hook Error] ${err.message}`);
+    // Exit 0 with allow to not block on hook errors (graceful degradation)
+    console.log(JSON.stringify({
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'allow'
+      }
+    }));
+    process.exit(0);
+  }
+}
+
+// Handle stdin properly
+process.stdin.setEncoding('utf8');
+main();

package/scripts/hooks/entry/claude-code/session-end.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Claude Code SessionEnd Hook
+ *
+ * Called when a Claude Code session ends.
+ * Auto-logs to request-log.md and warns about uncommitted work.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
+const { claudeCodeAdapter } = require('../../adapters/claude-code');
+
+// Import from parent scripts directory
+const { getConfig, PATHS } = require('../../../flow-utils');
+
+/**
+ * Get uncommitted file count
+ */
+function getUncommittedCount() {
+  try {
+    const output = execSync('git status --porcelain', {
+      cwd: PATHS.root,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    return output.trim().split('\n').filter(line => line.trim()).length;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Check if auto-logging is enabled
+ */
+function isAutoLoggingEnabled() {
+  const config = getConfig();
+  return config.hooks?.rules?.autoLogging?.enabled !== false;
+}
+
+async function main() {
+  try {
+    // Read input from stdin
+    let inputData = '';
+    for await (const chunk of process.stdin) {
+      inputData += chunk;
+    }
+
+    const input = inputData ? JSON.parse(inputData) : {};
+    const parsedInput = claudeCodeAdapter.parseInput(input);
+
+    const result = {
+      logged: false,
+      warning: null
+    };
+
+    // Check for uncommitted work
+    const uncommitted = getUncommittedCount();
+    if (uncommitted > 0) {
+      result.warning = `${uncommitted} uncommitted file${uncommitted !== 1 ? 's' : ''}. Consider committing before ending session.`;
+    }
+
+    // Auto-logging would go here but requires more session context
+    // For now, just warn about uncommitted work
+    if (isAutoLoggingEnabled()) {
+      // Could integrate with flow-session-end.js in the future
+      result.logged = false;
+    }
+
+    // Transform to Claude Code format
+    const output = claudeCodeAdapter.transformResult('SessionEnd', result);
+
+    // Output JSON
+    console.log(JSON.stringify(output));
+    process.exit(0);
+  } catch (err) {
+    // Non-blocking error
+    console.error(`[Wogi Flow Hook Error] ${err.message}`);
+    console.log(JSON.stringify({ continue: true }));
+    process.exit(0);
+  }
+}
+
+// Handle stdin properly
+process.stdin.setEncoding('utf8');
+main();

package/scripts/hooks/entry/claude-code/session-start.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Claude Code SessionStart Hook
+ *
+ * Called when a Claude Code session starts.
+ * Injects context (suspended tasks, decisions, recent activity).
+ */
+
+const { gatherSessionContext } = require('../../core/session-context');
+const { claudeCodeAdapter } = require('../../adapters/claude-code');
+
+async function main() {
+  try {
+    // Read input from stdin
+    let inputData = '';
+    for await (const chunk of process.stdin) {
+      inputData += chunk;
+    }
+
+    const input = inputData ? JSON.parse(inputData) : {};
+    const parsedInput = claudeCodeAdapter.parseInput(input);
+
+    // Gather session context
+    const coreResult = gatherSessionContext({
+      includeSuspended: true,
+      includeDecisions: true,
+      includeActivity: true
+    });
+
+    // Transform to Claude Code format
+    const output = claudeCodeAdapter.transformResult('SessionStart', coreResult);
+
+    // Output JSON
+    console.log(JSON.stringify(output));
+    process.exit(0);
+  } catch (err) {
+    // Non-blocking error - log to stderr, exit 1
+    console.error(`[Wogi Flow Hook Error] ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// Handle stdin properly
+process.stdin.setEncoding('utf8');
+main();

package/scripts/hooks/entry/claude-code/stop.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Claude Code Stop Hook
+ *
+ * Called when Claude is about to stop.
+ * Enforces loop completion - blocks stop if acceptance criteria incomplete.
+ */
+
+const { checkLoopExit } = require('../../core/loop-check');
+const { claudeCodeAdapter } = require('../../adapters/claude-code');
+
+async function main() {
+  try {
+    // Read input from stdin
+    let inputData = '';
+    for await (const chunk of process.stdin) {
+      inputData += chunk;
+    }
+
+    const input = inputData ? JSON.parse(inputData) : {};
+    const parsedInput = claudeCodeAdapter.parseInput(input);
+
+    // Check if loop can exit
+    const coreResult = checkLoopExit();
+
+    // Transform to Claude Code format
+    const output = claudeCodeAdapter.transformResult('Stop', coreResult);
+
+    // Output JSON
+    console.log(JSON.stringify(output));
+    process.exit(0);
+  } catch (err) {
+    // On error, allow stop (don't block user)
+    console.error(`[Wogi Flow Hook Error] ${err.message}`);
+    console.log(JSON.stringify({ continue: false })); // Allow stop
+    process.exit(0);
+  }
+}
+
+// Handle stdin properly
+process.stdin.setEncoding('utf8');
+main();

package/scripts/postinstall.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+/**
+ * WogiFlow postinstall script
+ *
+ * Runs after npm install to set up project structure.
+ * Creates necessary directories and copies template files for fresh installs.
+ * Preserves existing user data (never overwrites).
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Directory structure
+const WORKFLOW_DIR = '.workflow';
+const STATE_DIR = path.join(WORKFLOW_DIR, 'state');
+const CHANGES_DIR = path.join(WORKFLOW_DIR, 'changes');
+const MEMORY_DIR = path.join(WORKFLOW_DIR, 'memory');
+const VERIFICATIONS_DIR = path.join(WORKFLOW_DIR, 'verifications');
+const SPECS_DIR = path.join(WORKFLOW_DIR, 'specs');
+
+// Find template directory (relative to this script's location in node_modules)
+function findTemplateDir() {
+  // When installed via npm, templates are in the package
+  const npmPath = path.join(__dirname, '..', '.workflow', 'state');
+  if (fs.existsSync(npmPath)) {
+    return npmPath;
+  }
+
+  // Fallback for local development
+  const localPath = path.join(process.cwd(), '.workflow', 'state');
+  if (fs.existsSync(localPath)) {
+    return localPath;
+  }
+
+  return null;
+}
+
+// Template files to copy (without .template extension in target)
+const TEMPLATES = [
+  'ready.json',
+  'request-log.md',
+  'progress.md',
+  'app-map.md',
+  'decisions.md',
+  'component-index.json',
+  'feedback-patterns.md',
+  'architecture.md',
+  'stack.md',
+  'testing.md',
+  'session-state.json',
+  'knowledge-sync.json'
+];
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+    return true;
+  }
+  return false;
+}
+
+function createGitkeep(dir) {
+  const gitkeepPath = path.join(dir, '.gitkeep');
+  if (!fs.existsSync(gitkeepPath)) {
+    fs.writeFileSync(gitkeepPath, '');
+  }
+}
+
+function copyTemplates(templateDir) {
+  let copied = 0;
+
+  for (const file of TEMPLATES) {
+    const templatePath = path.join(templateDir, `${file}.template`);
+    const targetPath = path.join(STATE_DIR, file);
+
+    // Only copy if target doesn't exist (preserve user data)
+    if (!fs.existsSync(targetPath) && fs.existsSync(templatePath)) {
+      try {
+        fs.copyFileSync(templatePath, targetPath);
+        console.log(`  \x1b[32m✓\x1b[0m Created ${file}`);
+        copied++;
+      } catch (err) {
+        console.log(`  \x1b[33m!\x1b[0m Could not create ${file}: ${err.message}`);
+      }
+    }
+  }
+
+  return copied;
+}
+
+function main() {
+  // Skip if running in CI or non-interactive environment
+  if (process.env.CI || process.env.WOGIFLOW_SKIP_POSTINSTALL) {
+    return;
+  }
+
+  console.log('\n\x1b[36mWogiFlow\x1b[0m: Setting up project structure...\n');
+
+  // Create directory structure
+  const dirsCreated = [];
+
+  if (ensureDir(WORKFLOW_DIR)) dirsCreated.push(WORKFLOW_DIR);
+  if (ensureDir(STATE_DIR)) dirsCreated.push(STATE_DIR);
+  if (ensureDir(CHANGES_DIR)) dirsCreated.push(CHANGES_DIR);
+  if (ensureDir(MEMORY_DIR)) dirsCreated.push(MEMORY_DIR);
+  if (ensureDir(VERIFICATIONS_DIR)) dirsCreated.push(VERIFICATIONS_DIR);
+  if (ensureDir(SPECS_DIR)) dirsCreated.push(SPECS_DIR);
+
+  // Create .gitkeep files to preserve empty directories
+  createGitkeep(CHANGES_DIR);
+  createGitkeep(VERIFICATIONS_DIR);
+  createGitkeep(SPECS_DIR);
+
+  if (dirsCreated.length > 0) {
+    console.log(`  \x1b[32m✓\x1b[0m Created directories: ${dirsCreated.join(', ')}`);
+  }
+
+  // Find and copy templates
+  const templateDir = findTemplateDir();
+
+  if (templateDir) {
+    const copied = copyTemplates(templateDir);
+    if (copied > 0) {
+      console.log(`\n  \x1b[32m✓\x1b[0m Initialized ${copied} state files from templates`);
+    }
+  }
+
+  console.log('\n\x1b[36mWogiFlow\x1b[0m: Setup complete!');
+  console.log('  Run \x1b[33mflow onboard\x1b[0m to analyze your project.\n');
+}
+
+// Run
+try {
+  main();
+} catch (err) {
+  // Don't fail install on postinstall errors
+  console.log(`\x1b[33mWogiFlow postinstall warning:\x1b[0m ${err.message}`);
+}

package/templates/browser-test-flow.json

@@ -0,0 +1,56 @@
+{
+  "name": "[flow-name]",
+  "description": "[What this flow tests]",
+  "created": "[date]",
+  "tags": ["#e2e", "#screen:[name]"],
+  "baseUrl": "http://localhost:3000",
+  "steps": [
+    {
+      "action": "navigate",
+      "url": "/path",
+      "description": "Go to the target page"
+    },
+    {
+      "action": "wait",
+      "selector": ".page-loaded",
+      "timeout": 5000,
+      "description": "Wait for page to load"
+    },
+    {
+      "action": "type",
+      "selector": "#email",
+      "value": "test@example.com",
+      "description": "Enter email address"
+    },
+    {
+      "action": "type",
+      "selector": "#password",
+      "value": "password123",
+      "description": "Enter password"
+    },
+    {
+      "action": "click",
+      "selector": "button[type=submit]",
+      "description": "Submit the form"
+    },
+    {
+      "action": "verify",
+      "selector": ".dashboard",
+      "exists": true,
+      "description": "Verify dashboard is visible"
+    },
+    {
+      "action": "verify",
+      "selector": ".welcome-message",
+      "contains": "Welcome",
+      "description": "Verify welcome message"
+    },
+    {
+      "action": "screenshot",
+      "name": "dashboard-loaded",
+      "description": "Capture final state"
+    }
+  ],
+  "expectedResult": "[What should happen when flow completes]",
+  "relatedStory": "TASK-XXX"
+}

package/templates/bug-report.md

@@ -0,0 +1,43 @@
+# wf-XXXXXXXX: [Title]
+
+**Created**: [date]
+**Status**: Open / In Progress / Fixed / Closed
+**Severity**: Critical / High / Medium / Low
+**Priority**: P0-P4
+**Tags**: #bug #component:[name] #screen:[name]
+**Discovered From**: [wf-XXXXXXXX or empty if not during task]
+**Discovered During**: implementation / testing / review
+
+## Description
+[Clear description of the bug]
+
+## Steps to Reproduce
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+
+## Expected Behavior
+[What should happen]
+
+## Actual Behavior
+[What actually happens]
+
+## Environment
+- Browser: 
+- OS: 
+- Version: 
+
+## Screenshots
+[If applicable]
+
+## Possible Fix
+[If you have ideas about what's causing it or how to fix]
+
+## Related
+- [Related request-log entries]
+- [Related components from app-map]
+
+## Resolution
+[Fill in when fixed]
+- Fixed in: [commit/PR]
+- Root cause: [explanation]

package/templates/component-detail.md

@@ -0,0 +1,42 @@
+# [Component Name]
+
+**Path**: `src/components/[path]`
+**Status**: complete | in-progress | planned
+
+## Variants
+
+| Variant | Description |
+|---------|-------------|
+| `primary` | Main action style |
+| `secondary` | Secondary action style |
+
+## Props
+
+| Prop | Type | Required | Default | Description |
+|------|------|----------|---------|-------------|
+| `variant` | string | no | `primary` | Visual style |
+| `size` | `sm` \| `md` \| `lg` | no | `md` | Component size |
+| `disabled` | boolean | no | `false` | Disabled state |
+| `onClick` | function | no | - | Click handler |
+
+## Usage
+
+```tsx
+import { ComponentName } from '@/components/[path]'
+
+<ComponentName variant="primary" size="lg">
+  Label
+</ComponentName>
+```
+
+## Used In
+
+- ScreenName
+- ModalName
+- OtherComponent
+
+## Notes
+
+- Any special behaviors or gotchas
+- Performance considerations
+- Accessibility notes

package/templates/component.stories.tsx

@@ -0,0 +1,49 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { [ComponentName] } from './[ComponentName]';
+
+const meta: Meta<typeof [ComponentName]> = {
+  title: 'Components/[ComponentName]',
+  component: [ComponentName],
+  parameters: {
+    layout: 'centered',
+  },
+  tags: ['autodocs'],
+  argTypes: {
+    // Add argTypes based on props
+    // variant: {
+    //   control: 'select',
+    //   options: ['primary', 'secondary'],
+    // },
+  },
+};
+
+export default meta;
+type Story = StoryObj<typeof meta>;
+
+// Default story
+export const Default: Story = {
+  args: {
+    // Add default props
+  },
+};
+
+// Variant stories
+// export const Primary: Story = {
+//   args: {
+//     variant: 'primary',
+//   },
+// };
+
+// export const Secondary: Story = {
+//   args: {
+//     variant: 'secondary',
+//   },
+// };
+
+// Interactive story
+// export const Interactive: Story = {
+//   args: {},
+//   play: async ({ canvasElement }) => {
+//     // Add interaction tests
+//   },
+// };