salmon-loop 0.2.3

package/dist/core/slash/router.js

@@ -0,0 +1,76 @@
+import { Pipeline } from '../grizzco/engine/pipeline/pipeline.js';
+import { parseSlashInput } from './parser.js';
+import { buildSlashDecideStep } from './steps/slash-decide.js';
+import { buildSlashExecuteStep } from './steps/slash-execute.js';
+export class SlashRouter {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async dispatch(input, meta) {
+        const parsed = parseSlashInput(input);
+        const ctx = {
+            input: {
+                raw: parsed.raw,
+                trimmed: parsed.trimmed,
+                isSlash: parsed.kind === 'slash',
+                commandName: parsed.commandName,
+                argsText: parsed.argsText,
+                tokens: parsed.tokens,
+            },
+            resolved: parsed.kind === 'slash'
+                ? { command: this.options.registry.find(parsed.commandName) }
+                : undefined,
+            data: {},
+        };
+        const final = await Pipeline.of(ctx)
+            .step('slash.decide', buildSlashDecideStep())
+            .step('slash.execute', buildSlashExecuteStep(this.options, meta))
+            .execute();
+        if (!final.success) {
+            return {
+                kind: 'block',
+                code: 'INTERNAL_ERROR',
+                details: { message: final.error?.message, lastStep: final.lastStep },
+            };
+        }
+        const decision = final.data?.data?.__decision;
+        return decision ?? { kind: 'consumed' };
+    }
+    async suggest(input, meta) {
+        const parsed = parseSlashInput(input);
+        if (parsed.kind !== 'slash')
+            return [];
+        const cmdName = parsed.commandName;
+        const spec = this.options.registry.find(cmdName);
+        const suggestion = parsed.suggestion;
+        const argIndex = suggestion?.argIndex ?? 0;
+        // Delegate to handler when a command is exactly matched and we are in the arg area.
+        if (spec && argIndex > 0) {
+            const handler = this.options.handlers.getHandler(spec.name);
+            if (handler?.getSuggestions) {
+                const items = await handler.getSuggestions({
+                    rawInput: parsed.raw,
+                    command: spec,
+                    argsText: parsed.argsText ?? '',
+                    tokens: parsed.tokens ?? [],
+                    meta,
+                });
+                return items.map((i) => ({
+                    name: i.name,
+                    description: i.description,
+                    commandName: spec.name,
+                }));
+            }
+            return [];
+        }
+        const prefix = suggestion?.currentPrefix ?? cmdName;
+        const base = this.options.registry.suggest(prefix);
+        return base.map((i) => ({
+            name: i.name,
+            description: i.description,
+            commandName: i.name.trim(),
+        }));
+    }
+}
+//# sourceMappingURL=router.js.map

package/dist/core/slash/steps/slash-decide.js

@@ -0,0 +1,19 @@
+import { MicroTaskRunner } from '../../grizzco/dsl/MicroTaskRunner.js';
+import { SlashStrategyDSL } from '../strategy.js';
+export function buildSlashDecideStep() {
+    return async (context) => {
+        const runner = new MicroTaskRunner({
+            debugLabel: 'SlashRouter',
+            strategy: (engine) => {
+                SlashStrategyDSL(engine);
+                return engine;
+            },
+            resolveData: async () => undefined,
+            maxRounds: 2,
+        });
+        const result = await runner.decide(context);
+        const data = (context.data ?? {});
+        return { ...context, data: { ...data, __plan: result.plan } };
+    };
+}
+//# sourceMappingURL=slash-decide.js.map

package/dist/core/slash/steps/slash-execute.js

@@ -0,0 +1,73 @@
+function planToDecision(plan, options) {
+    const action = plan.actions[0];
+    if (!action)
+        return { kind: 'consumed' };
+    if (action.type === 'FORWARD_TEXT') {
+        const next = String(action.params?.input ?? '');
+        return { kind: 'forward', input: next };
+    }
+    if (action.type === 'UNKNOWN_SLASH') {
+        const cmd = String(action.params?.commandName ?? '');
+        if (options.unknownSlashPolicy === 'forward_as_text') {
+            return { kind: 'forward', input: cmd };
+        }
+        return { kind: 'block', code: 'UNKNOWN_SLASH', details: { commandName: cmd } };
+    }
+    // EXECUTE_SLASH is handled in the macro layer.
+    return { kind: 'consumed' };
+}
+export function buildSlashExecuteStep(options, meta) {
+    return async (context) => {
+        const data = (context.data ?? {});
+        const plan = data.__plan;
+        if (!plan) {
+            return { ...context, data: { ...data, __decision: { kind: 'consumed' } } };
+        }
+        const action = plan.actions[0];
+        if (!action) {
+            return { ...context, data: { ...data, __decision: { kind: 'consumed' } } };
+        }
+        if (action.type !== 'EXECUTE_SLASH') {
+            const decision = planToDecision(plan, { unknownSlashPolicy: options.unknownSlashPolicy });
+            return { ...context, data: { ...data, __decision: decision } };
+        }
+        const commandName = String(action.params?.commandName ?? '');
+        const spec = options.registry.find(commandName);
+        if (!spec) {
+            const decision = planToDecision({ ...plan, actions: [{ type: 'UNKNOWN_SLASH', params: { commandName } }] }, { unknownSlashPolicy: options.unknownSlashPolicy });
+            return { ...context, data: { ...data, __decision: decision } };
+        }
+        const handler = options.handlers.getHandler(spec.name);
+        if (!handler) {
+            return {
+                ...context,
+                data: {
+                    ...data,
+                    __decision: { kind: 'block', code: 'NO_HANDLER', details: { commandName: spec.name } },
+                },
+            };
+        }
+        const req = {
+            rawInput: context.input.raw,
+            command: spec,
+            argsText: String(action.params?.argsText ?? ''),
+            tokens: Array.isArray(action.params?.tokens) ? action.params.tokens : [],
+            meta,
+        };
+        const result = await handler.execute(req);
+        if (result.kind === 'rewrite') {
+            return {
+                ...context,
+                data: { ...data, __decision: { kind: 'rewrite', input: result.input } },
+            };
+        }
+        if (result.kind === 'forward') {
+            return {
+                ...context,
+                data: { ...data, __decision: { kind: 'forward', input: result.input } },
+            };
+        }
+        return { ...context, data: { ...data, __decision: { kind: 'consumed' } } };
+    };
+}
+//# sourceMappingURL=slash-execute.js.map

package/dist/core/slash/steps/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/slash/strategy.js

@@ -0,0 +1,33 @@
+/**
+ * SlashStrategyDSL routes slash-prefixed inputs to command handlers.
+ *
+ * COMPLIANCE: DSL-Spec-V3
+ * - No async/I/O here.
+ * - Only declare dependencies and plan actions.
+ */
+export const SlashStrategyDSL = (engine) => {
+    engine
+        .phase('Input Validation')
+        .require((c) => typeof c.input?.raw === 'string', 'No input provided')
+        .phase('Non-Slash Forwarding')
+        .when((c) => !c.input.isSlash, (p) => {
+        p.setWorker('slash.forward');
+        p.addAction('FORWARD_TEXT', { input: engine.ctx.input.trimmed });
+    })
+        .phase('Slash Execution')
+        .when((c) => c.input.isSlash && Boolean(c.resolved?.command), (p) => {
+        p.setWorker('slash.execute');
+        p.addAction('EXECUTE_SLASH', {
+            commandName: engine.ctx.resolved.command.name,
+            argsText: engine.ctx.input.argsText ?? '',
+            tokens: engine.ctx.input.tokens ?? [],
+        });
+    })
+        .phase('Unknown Slash')
+        .when((c) => c.input.isSlash && !c.resolved?.command, (p) => {
+        p.setWorker('slash.unknown');
+        p.addAction('UNKNOWN_SLASH', { commandName: engine.ctx.input.commandName ?? '' });
+    });
+    return engine;
+};
+//# sourceMappingURL=strategy.js.map

package/dist/core/slash/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map