juno-code 1.0.36 → 1.0.38

package/README.md

@@ -192,6 +192,176 @@ juno-code feedback --interactive
 juno-code start -b shell -s claude --enable-feedback -i 10
 ```
 
+## Slack Integration
+
+juno-code includes built-in Slack integration for team collaboration. The system monitors Slack channels and creates kanban tasks from messages, then posts agent responses as threaded replies.
+
+### How It Works
+
+1. **Fetch**: `slack_fetch.sh` monitors a Slack channel and creates kanban tasks from new messages
+2. **Process**: The AI agent processes tasks and records responses in the kanban
+3. **Respond**: `slack_respond.sh` sends agent responses back to Slack as threaded replies
+
+This enables a workflow where team members can submit tasks via Slack and receive AI-generated responses without leaving their chat interface.
+
+### Setup
+
+1. **Create a Slack App**:
+   - Go to https://api.slack.com/apps and create a new app
+   - Under "OAuth & Permissions", add these scopes:
+     - `channels:history`, `channels:read` (public channels)
+     - `groups:history`, `groups:read` (private channels)
+     - `users:read` (user info)
+     - `chat:write` (send messages)
+   - Install the app to your workspace
+   - Copy the "Bot User OAuth Token" (starts with `xoxb-`)
+
+2. **Configure Environment**:
+   ```bash
+   # In project root .env file
+   SLACK_BOT_TOKEN=xoxb-your-token-here
+   SLACK_CHANNEL=bug-reports
+   ```
+
+3. **Usage**:
+   ```bash
+   # Fetch messages from Slack and create tasks
+   ./.juno_task/scripts/slack_fetch.sh --channel bug-reports
+
+   # Continuous monitoring mode
+   ./.juno_task/scripts/slack_fetch.sh --channel feature-requests --continuous
+
+   # Send completed task responses back to Slack
+   ./.juno_task/scripts/slack_respond.sh --tag slack-input
+
+   # Dry run to preview what would be sent
+   ./.juno_task/scripts/slack_respond.sh --dry-run --verbose
+   ```
+
+### Automated Slack Workflow with Hooks
+
+Use the `--pre-run` flag to sync with Slack before each juno-code run:
+
+```bash
+# Fetch Slack messages before starting work
+./.juno_task/scripts/run_until_completion.sh \
+  --pre-run "./.juno_task/scripts/slack_fetch.sh --channel bug-reports" \
+  -s claude -i 5 -v
+```
+
+Or configure hooks in `.juno_task/config.json`:
+
+```json
+{
+  "hooks": {
+    "SLACK_SYNC": {
+      "commands": [
+        "./.juno_task/scripts/slack_fetch.sh --channel bug-reports",
+        "./.juno_task/scripts/slack_respond.sh --tag slack-input"
+      ]
+    }
+  }
+}
+```
+
+Then run with the hook:
+
+```bash
+./.juno_task/scripts/run_until_completion.sh --pre-run-hook SLACK_SYNC -s claude -i 5 -v
+```
+
+## run_until_completion.sh
+
+The `run_until_completion.sh` script continuously runs juno-code until all kanban tasks are completed. It uses a do-while loop pattern: juno-code runs at least once, then continues while tasks remain in backlog, todo, or in_progress status.
+
+### Basic Usage
+
+```bash
+# Run until all tasks complete
+./.juno_task/scripts/run_until_completion.sh -s claude -i 5 -v
+
+# With custom backend and model
+./.juno_task/scripts/run_until_completion.sh -b shell -s codex -m :codex -i 10
+```
+
+### Pre-run Commands (--pre-run)
+
+Execute commands before the main loop starts. Useful for syncing with external services, running linters, or preparing the environment.
+
+```bash
+# Single pre-run command
+./.juno_task/scripts/run_until_completion.sh --pre-run "./scripts/lint.sh" -s claude -i 5
+
+# Multiple pre-run commands (executed in order)
+./.juno_task/scripts/run_until_completion.sh \
+  --pre-run "./scripts/sync.sh" \
+  --pre-run "npm run build" \
+  -s claude -i 5 -v
+
+# Alternative: use environment variable
+JUNO_PRE_RUN="./scripts/prepare.sh" \
+  ./.juno_task/scripts/run_until_completion.sh -s claude -i 5
+```
+
+### Pre-run Hooks (--pre-run-hook)
+
+Execute named hooks defined in `.juno_task/config.json`. Hooks group multiple commands that run together.
+
+**Define hooks in config.json:**
+```json
+{
+  "hooks": {
+    "START_ITERATION": {
+      "commands": [
+        "./scripts/lint.sh",
+        "npm run typecheck"
+      ]
+    },
+    "SLACK_SYNC": {
+      "commands": [
+        "./.juno_task/scripts/slack_fetch.sh --channel bugs",
+        "./.juno_task/scripts/slack_respond.sh"
+      ]
+    }
+  }
+}
+```
+
+**Use hooks:**
+```bash
+# Single hook
+./.juno_task/scripts/run_until_completion.sh --pre-run-hook START_ITERATION -s claude -i 5
+
+# Multiple hooks (executed in order)
+./.juno_task/scripts/run_until_completion.sh \
+  --pre-run-hook SLACK_SYNC \
+  --pre-run-hook START_ITERATION \
+  -s claude -i 5
+
+# Alternative: use environment variable
+JUNO_PRE_RUN_HOOK="START_ITERATION" \
+  ./.juno_task/scripts/run_until_completion.sh -s claude -i 5
+```
+
+### Execution Order
+
+When both hooks and pre-run commands are specified, the execution order is:
+1. Hooks from `JUNO_PRE_RUN_HOOK` env var
+2. Hooks from `--pre-run-hook` flags (in order)
+3. Commands from `JUNO_PRE_RUN` env var
+4. Commands from `--pre-run` flags (in order)
+5. Main juno-code loop begins
+
+### Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `JUNO_DEBUG=true` | Show debug diagnostic messages |
+| `JUNO_VERBOSE=true` | Show informational status messages |
+| `JUNO_PRE_RUN` | Pre-run command (runs before --pre-run flags) |
+| `JUNO_PRE_RUN_HOOK` | Pre-run hook name (runs before --pre-run-hook flags) |
+| `JUNO_RUN_UNTIL_MAX_ITERATIONS` | Maximum iterations (0 = unlimited) |
+
 ## Kanban Commands
 
 The kanban.sh script wraps juno-kanban. Here are the actual commands:

package/dist/bin/cli.js

@@ -318,6 +318,13 @@ var init_default_hooks = __esm({
   "src/templates/default-hooks.ts"() {
     init_version();
     DEFAULT_HOOKS = {
+      // Executes once at the beginning of a run (before all iterations)
+      // Use for: setup, environment checks, notifications, pre-run cleanup
+      START_RUN: {
+        commands: []
+      },
+      // Executes at the start of each iteration
+      // Use for: file monitoring, state checks, per-iteration setup
       START_ITERATION: {
         commands: [
           // Monitor CLAUDE.md file size
@@ -326,6 +333,16 @@ var init_default_hooks = __esm({
           'file="AGENTS.md"; lines=$(wc -l < "$file" 2>/dev/null || echo 0); chars=$(wc -m < "$file" 2>/dev/null || echo 0); if [ "$lines" -gt 450 ] || [ "$chars" -gt 60000 ]; then juno-kanban "[Critical] file $file is too large, keep it lean and useful for every run of the agent."; fi',
           "./.juno_task/scripts/cleanup_feedback.sh"
         ]
+      },
+      // Executes at the end of each iteration
+      // Use for: validation, logging, per-iteration cleanup, progress tracking
+      END_ITERATION: {
+        commands: []
+      },
+      // Executes once at the end of a run (after all iterations complete)
+      // Use for: final cleanup, notifications, reports, post-run actions
+      END_RUN: {
+        commands: []
       }
     };
   }
@@ -13393,12 +13410,24 @@ var init_script_installer = __esm({
       /**
        * Required scripts include both standalone scripts and their dependencies.
        * kanban.sh depends on install_requirements.sh for Python venv setup.
+       * Slack integration scripts allow fetching tasks from Slack and responding.
        */
       static REQUIRED_SCRIPTS = [
         "run_until_completion.sh",
         "kanban.sh",
-        "install_requirements.sh"
+        "install_requirements.sh",
         // Required by kanban.sh for Python venv creation
+        // Slack integration scripts
+        "slack_state.py",
+        // State management for Slack integration
+        "slack_fetch.py",
+        // Core logic for fetching Slack messages
+        "slack_fetch.sh",
+        // Wrapper script for Slack fetch
+        "slack_respond.py",
+        // Core logic for sending responses to Slack
+        "slack_respond.sh"
+        // Wrapper script for Slack respond
       ];
       /**
        * Get the templates scripts directory from the package
@@ -13587,6 +13616,115 @@ var init_script_installer = __esm({
         }
         return results;
       }
+      /**
+       * Get scripts that need updates based on content comparison
+       * @param projectDir - The project root directory
+       * @returns Array of script names that have different content from package version
+       */
+      static async getOutdatedScripts(projectDir) {
+        const outdated = [];
+        const packageScriptsDir = this.getPackageScriptsDir();
+        if (!packageScriptsDir) {
+          return outdated;
+        }
+        for (const script of this.REQUIRED_SCRIPTS) {
+          const sourcePath = path3__namespace.join(packageScriptsDir, script);
+          const destPath = path3__namespace.join(projectDir, ".juno_task", "scripts", script);
+          if (!await fs3__default.default.pathExists(sourcePath)) {
+            continue;
+          }
+          if (!await fs3__default.default.pathExists(destPath)) {
+            continue;
+          }
+          try {
+            const [sourceContent, destContent] = await Promise.all([
+              fs3__default.default.readFile(sourcePath, "utf-8"),
+              fs3__default.default.readFile(destPath, "utf-8")
+            ]);
+            if (sourceContent !== destContent) {
+              outdated.push(script);
+            }
+          } catch {
+            outdated.push(script);
+          }
+        }
+        return outdated;
+      }
+      /**
+       * Check if any scripts need installation or update
+       * @param projectDir - The project root directory
+       * @returns true if any scripts need to be installed or updated
+       */
+      static async needsUpdate(projectDir) {
+        try {
+          const junoTaskDir = path3__namespace.join(projectDir, ".juno_task");
+          if (!await fs3__default.default.pathExists(junoTaskDir)) {
+            return false;
+          }
+          const missing = await this.getMissingScripts(projectDir);
+          if (missing.length > 0) {
+            return true;
+          }
+          const outdated = await this.getOutdatedScripts(projectDir);
+          return outdated.length > 0;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Automatically update scripts - installs missing AND updates outdated scripts
+       * Similar to ServiceInstaller.autoUpdate(), this ensures project scripts
+       * are always in sync with the package version.
+       *
+       * This should be called on every CLI run to ensure scripts are up-to-date.
+       * @param projectDir - The project root directory
+       * @param silent - If true, suppresses console output
+       * @returns true if any scripts were installed or updated
+       */
+      static async autoUpdate(projectDir, silent = true) {
+        try {
+          const debug = process.env.JUNO_CODE_DEBUG === "1";
+          const junoTaskDir = path3__namespace.join(projectDir, ".juno_task");
+          if (!await fs3__default.default.pathExists(junoTaskDir)) {
+            return false;
+          }
+          const missing = await this.getMissingScripts(projectDir);
+          const outdated = await this.getOutdatedScripts(projectDir);
+          if (debug) {
+            if (missing.length > 0) {
+              console.error(`[DEBUG] ScriptInstaller: Missing scripts: ${missing.join(", ")}`);
+            }
+            if (outdated.length > 0) {
+              console.error(`[DEBUG] ScriptInstaller: Outdated scripts: ${outdated.join(", ")}`);
+            }
+          }
+          if (missing.length === 0 && outdated.length === 0) {
+            return false;
+          }
+          const scriptsToUpdate = [.../* @__PURE__ */ new Set([...missing, ...outdated])];
+          let updatedAny = false;
+          for (const script of scriptsToUpdate) {
+            const installed = await this.installScript(projectDir, script, silent);
+            if (installed) {
+              updatedAny = true;
+            }
+          }
+          if (updatedAny) {
+            if (debug) {
+              console.error(`[DEBUG] ScriptInstaller: Updated ${scriptsToUpdate.length} script(s)`);
+            }
+            if (!silent) {
+              console.log(`\u2713 Updated ${scriptsToUpdate.length} script(s) in .juno_task/scripts/`);
+            }
+          }
+          return updatedAny;
+        } catch (error) {
+          if (process.env.JUNO_CODE_DEBUG === "1") {
+            console.error("[DEBUG] ScriptInstaller: autoUpdate error:", error);
+          }
+          return false;
+        }
+      }
     };
   }
 });
@@ -24380,13 +24518,13 @@ async function main() {
   }
   try {
     const { ScriptInstaller: ScriptInstaller2 } = await Promise.resolve().then(() => (init_script_installer(), script_installer_exports));
-    const installed = await ScriptInstaller2.autoInstallMissing(process.cwd(), true);
-    if (installed && (process.argv.includes("--verbose") || process.argv.includes("-v") || process.env.JUNO_CODE_DEBUG === "1")) {
-      console.error("[DEBUG] Project scripts auto-installed to .juno_task/scripts/");
+    const updated = await ScriptInstaller2.autoUpdate(process.cwd(), true);
+    if (updated && (process.argv.includes("--verbose") || process.argv.includes("-v") || process.env.JUNO_CODE_DEBUG === "1")) {
+      console.error("[DEBUG] Project scripts auto-updated in .juno_task/scripts/");
     }
   } catch (error) {
     if (process.env.JUNO_CODE_DEBUG === "1") {
-      console.error("[DEBUG] Script auto-install failed:", error instanceof Error ? error.message : String(error));
+      console.error("[DEBUG] Script auto-update failed:", error instanceof Error ? error.message : String(error));
     }
   }
   program.name("juno-code").description("TypeScript implementation of juno-code CLI tool for AI subagent orchestration").version(VERSION, "-V, --version", "Display version information").helpOption("-h, --help", "Display help information");