diff --git a/gogo/gogo.commands/pom.xml b/gogo/gogo.commands/pom.xml
new file mode 100644
index 0000000..9b78ac6
--- /dev/null
+++ b/gogo/gogo.commands/pom.xml
@@ -0,0 +1,73 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <parent>
+        <groupId>org.apache.felix.gogo</groupId>
+        <artifactId>gogo</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <packaging>bundle</packaging>
+    <name>Apache Felix Gogo Shell Commands</name>
+    <artifactId>org.apache.felix.gogo.commands</artifactId>
+    <version>1.0.0-SNAPSHOT</version>
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.felix</groupId>
+            <artifactId>org.osgi.core</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.felix</groupId>
+            <artifactId>org.osgi.compendium</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.felix.gogo</groupId>
+            <artifactId>org.apache.felix.gogo.runtime</artifactId>
+        </dependency>
+    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.felix</groupId>
+                <artifactId>maven-bundle-plugin</artifactId>
+                <version>2.0.0</version>
+                <extensions>true</extensions>
+                <configuration>
+                    <instructions>
+                        <Export-Package>
+                            org.apache.felix.gogo.commands*;version=${pom.version},
+                        </Export-Package>
+                        <Import-Package>
+                            !org.apache.felix.gogo.commands.basic,
+                            !org.apache.felix.gogo.commands.converter,
+                            *
+                        </Import-Package>
+                        <Bundle-SymbolicName>${pom.artifactId}</Bundle-SymbolicName>
+                        <Bundle-Vendor>The Apache Software Foundation</Bundle-Vendor>
+                        <_versionpolicy>[$(version;==;$(@)),$(version;+;$(@)))</_versionpolicy>
+                        <_removeheaders>Private-Package,Ignore-Package</_removeheaders>
+                    </instructions>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/Action.java b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/Action.java
new file mode 100644
index 0000000..7979a41
--- /dev/null
+++ b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/Action.java
@@ -0,0 +1,28 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.felix.gogo.commands;
+
+import org.osgi.service.command.CommandSession;
+
+public interface Action
+{
+
+    Object execute(CommandSession session) throws Exception;
+
+}
diff --git a/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/Argument.java b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/Argument.java
new file mode 100644
index 0000000..e1b8f7f
--- /dev/null
+++ b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/Argument.java
@@ -0,0 +1,39 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.felix.gogo.commands;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.annotation.ElementType;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD})
+public @interface Argument
+{
+    String name() default "VAL";
+
+    String description() default "";
+
+    boolean required() default false;
+
+    int index() default 0;
+
+    boolean multiValued() default false;
+}
diff --git a/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/Command.java b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/Command.java
new file mode 100644
index 0000000..9f94e1f
--- /dev/null
+++ b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/Command.java
@@ -0,0 +1,35 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.felix.gogo.commands;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.annotation.ElementType;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface Command
+{
+    String scope();
+
+    String name();
+
+    String description() default "";
+}
diff --git a/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/Option.java b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/Option.java
new file mode 100644
index 0000000..0197ff5
--- /dev/null
+++ b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/Option.java
@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.felix.gogo.commands;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.annotation.ElementType;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD})
+public @interface Option
+{
+    String name();
+
+    String[] aliases() default {};
+
+    String description() default "";
+
+    boolean required() default false;
+
+    boolean multiValued() default false;
+
+}
diff --git a/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/basic/AbstractCommand.java b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/basic/AbstractCommand.java
new file mode 100644
index 0000000..39c7cf3
--- /dev/null
+++ b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/basic/AbstractCommand.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.felix.gogo.commands.basic;
+
+import java.util.List;
+
+import org.apache.felix.gogo.commands.basic.DefaultActionPreparator;
+import org.apache.felix.gogo.commands.basic.ActionPreparator;
+import org.apache.felix.gogo.commands.Action;
+import org.osgi.service.command.CommandSession;
+import org.osgi.service.command.Function;
+
+public abstract class AbstractCommand implements Function {
+
+    public Object execute(CommandSession session, List<Object> arguments) throws Exception {
+        Action action = createNewAction();
+        getPreparator().prepare(action, session, arguments);
+        return action.execute(session);
+    }
+
+    protected abstract Action createNewAction() throws Exception;
+
+    protected ActionPreparator getPreparator() throws Exception {
+        return new DefaultActionPreparator();
+    }
+
+}
diff --git a/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/basic/ActionPreparator.java b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/basic/ActionPreparator.java
new file mode 100644
index 0000000..b10303a
--- /dev/null
+++ b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/basic/ActionPreparator.java
@@ -0,0 +1,12 @@
+package org.apache.felix.gogo.commands.basic;
+
+import java.util.List;
+
+import org.osgi.service.command.CommandSession;
+import org.apache.felix.gogo.commands.Action;
+
+public interface ActionPreparator {
+
+    void prepare(Action action, CommandSession session, List<Object> arguments) throws Exception;
+
+}
diff --git a/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/basic/DefaultActionPreparator.java b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/basic/DefaultActionPreparator.java
new file mode 100644
index 0000000..a7d650c
--- /dev/null
+++ b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/basic/DefaultActionPreparator.java
@@ -0,0 +1,269 @@
+/**
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package org.apache.felix.gogo.commands.basic;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.lang.reflect.Type;
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Arrays;
+import java.util.Set;
+import java.util.HashSet;
+import java.io.PrintStream;
+
+import org.apache.felix.gogo.commands.Option;
+import org.apache.felix.gogo.commands.Action;
+import org.apache.felix.gogo.commands.Argument;
+import org.apache.felix.gogo.commands.Command;
+import org.apache.felix.gogo.commands.basic.ActionPreparator;
+import org.apache.felix.gogo.commands.converter.DefaultConverter;
+import org.osgi.service.command.CommandSession;
+
+public class DefaultActionPreparator implements ActionPreparator {
+
+    protected static final Option HELP = new Option() {
+        public String name()
+        {
+            return "--help";
+        }
+
+        public String[] aliases()
+        {
+            return new String[] { };
+        }
+
+        public String description()
+        {
+            return "Display this help message";
+        }
+
+        public boolean required()
+        {
+            return false;
+        }
+
+        public boolean multiValued()
+        {
+            return false;
+        }
+
+        public Class<? extends Annotation> annotationType()
+        {
+            return Option.class;
+        }
+    };
+
+    public void prepare(Action action, CommandSession session, List<Object> params) throws Exception
+    {
+        Map<Option, Field> options = new HashMap<Option, Field>();
+        Map<Argument, Field> arguments = new HashMap<Argument, Field>();
+        List<Argument> orderedArguments = new ArrayList<Argument>();
+        // Introspect
+        for (Class type = action.getClass(); type != null; type = type.getSuperclass()) {
+            for (Field field : type.getDeclaredFields()) {
+                Option option = field.getAnnotation(Option.class);
+                if (option != null) {
+                    options.put(option, field);
+                }
+                Argument argument = field.getAnnotation(Argument.class);
+                if (argument != null) {
+                    arguments.put(argument, field);
+                    int index = argument.index();
+                    while (orderedArguments.size() <= index) {
+                        orderedArguments.add(null);
+                    }
+                    if (orderedArguments.get(index) != null) {
+                        throw new IllegalArgumentException("Duplicate argument index: " + index);
+                    }
+                    orderedArguments.set(index, argument);
+                }
+            }
+        }
+        // Check indexes are correct
+        for (int i = 0; i < orderedArguments.size(); i++) {
+            if (orderedArguments.get(i) == null) {
+                throw new IllegalArgumentException("Missing argument for index: " + i);
+            }
+        }
+        // Populate
+        Map<Option, Object> optionValues = new HashMap<Option, Object>();
+        Map<Argument, Object> argumentValues = new HashMap<Argument, Object>();
+        boolean processOptions = true;
+        int argIndex = 0;
+        for (Iterator<Object> it = params.iterator(); it.hasNext();) {
+            Object param = it.next();
+            // Check for help
+            if (HELP.name().equals(param) || Arrays.asList(HELP.aliases()).contains(param)) {
+                printUsage(action.getClass().getAnnotation(Command.class), options.keySet(), arguments.keySet(), System.out);
+                return;
+            }
+            if (processOptions && param instanceof String && ((String) param).startsWith("-")) {
+                boolean isKeyValuePair = ((String) param).indexOf('=') != -1;
+                String name;
+                Object value = null;
+                if (isKeyValuePair) {
+                    name = ((String) param).substring(0, ((String) param).indexOf('='));
+                    value = ((String) param).substring(((String) param).indexOf('=') + 1);
+                } else {
+                    name = (String) param;
+                }
+                Option option = null;
+                for (Option opt : options.keySet()) {
+                    if (name.equals(opt.name()) || Arrays.binarySearch(opt.aliases(), name) >= 0) {
+                        option = opt;
+                        break;
+                    }
+                }
+                if (option == null) {
+                    throw new IllegalArgumentException("Undefined option: " + param);
+                }
+                Field field = options.get(option);
+                if (value == null && (field.getType() == boolean.class || field.getType() == Boolean.class)) {
+                    value = Boolean.TRUE;
+                }
+                if (value == null && it.hasNext()) {
+                    value = it.next();
+                }
+                if (value == null) {
+                    throw new IllegalArgumentException("Missing value for option " + param);
+                }
+                if (option.multiValued()) {
+                    List<Object> l = (List<Object>) optionValues.get(option);
+                    if (l == null) {
+                        l = new ArrayList<Object>();
+                        optionValues.put(option,  l);
+                    }
+                    l.add(value);
+                } else {
+                    optionValues.put(option, value);
+                }
+            } else {
+                processOptions = false;
+                if (argIndex >= orderedArguments.size()) {
+                    throw new IllegalArgumentException("Too many arguments specified");
+                }
+                Argument argument = orderedArguments.get(argIndex);
+                if (!argument.multiValued()) {
+                    argIndex++;
+                }
+                if (argument.multiValued()) {
+                    List<Object> l = (List<Object>) argumentValues.get(argument);
+                    if (l == null) {
+                        l = new ArrayList<Object>();
+                        argumentValues.put(argument, l);
+                    }
+                    l.add(param);
+                } else {
+                    argumentValues.put(argument, param);
+                }
+            }
+        }
+        // Check required arguments / options
+        for (Option option : options.keySet()) {
+            if (option.required() && optionValues.get(option) == null) {
+                throw new IllegalArgumentException("Option " + option.name() + " is required");
+            }
+        }
+        for (Argument argument : arguments.keySet()) {
+            if (argument.required() && argumentValues.get(argument) == null) {
+                throw new IllegalArgumentException("Argument " + argument.name() + " is required");
+            }
+        }
+        // Convert and inject values
+        for (Map.Entry<Option, Object> entry : optionValues.entrySet()) {
+            Field field = options.get(entry.getKey());
+            Object value = convert(action, session, entry.getValue(), field.getGenericType());
+            field.setAccessible(true);
+            field.set(action, value);
+        }
+        for (Map.Entry<Argument, Object> entry : argumentValues.entrySet()) {
+            Field field = arguments.get(entry.getKey());
+            Object value = convert(action, session, entry.getValue(), field.getGenericType());
+            field.setAccessible(true);
+            field.set(action, value);
+        }
+    }
+
+    protected void printUsage(Command command, Set<Option> options, Set<Argument> arguments, PrintStream out)
+    {
+        options = new HashSet<Option>(options);
+        options.add(HELP);
+        if (command != null && command.description() != null && command.description().length() > 0)
+        {
+            out.println(command.description());
+            out.println();
+        }
+        String syntax = "syntax: ";
+        if (command != null)
+        {
+            syntax += command.scope() + ":" + command.name();
+        }
+        if (options.size() > 0)
+        {
+            syntax += " [options]";
+        }
+        if (arguments.size() > 0)
+        {
+            syntax += " [arguments]";
+        }
+        out.println(syntax);
+        out.println();
+        if (arguments.size() > 0)
+        {
+            out.println("arguments:");
+            for (Argument argument : arguments)
+            {
+                out.print("  ");
+                out.print(argument.name());
+                out.print("  ");
+                out.print(argument.description());
+                out.println();
+            }
+            out.println();
+        }
+        if (options.size() > 0)
+        {
+            out.println("options:");
+            for (Option option : options)
+            {
+                out.print("  ");
+                out.print(option.name());
+                out.print("  ");
+                if (option.aliases().length > 0)
+                {
+                    out.print("(");
+                    out.print(Arrays.toString(option.aliases()));
+                    out.print(")  ");
+                }
+                out.print(option.description());
+                out.println();
+            }
+            out.println();
+        }
+    }
+
+    protected Object convert(Action action, CommandSession session, Object value, Type toType) throws Exception
+    {
+        return new DefaultConverter(action.getClass().getClassLoader()).convert(value, toType);
+    }
+
+}
diff --git a/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/basic/SimpleCommand.java b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/basic/SimpleCommand.java
new file mode 100644
index 0000000..8d7ba46
--- /dev/null
+++ b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/basic/SimpleCommand.java
@@ -0,0 +1,71 @@
+/**
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package org.apache.felix.gogo.commands.basic;
+
+import java.util.Hashtable;
+
+import org.osgi.framework.ServiceRegistration;
+import org.osgi.framework.BundleContext;
+import org.osgi.service.command.Function;
+import org.apache.felix.gogo.commands.basic.AbstractCommand;
+import org.apache.felix.gogo.commands.Action;
+import org.apache.felix.gogo.commands.Command;
+
+public class SimpleCommand extends AbstractCommand {
+
+    private Class<? extends Action> actionClass;
+
+    public SimpleCommand()
+    {
+    }
+
+    public SimpleCommand(Class<? extends Action> actionClass)
+    {
+        this.actionClass = actionClass;
+    }
+
+    public Class<? extends Action> getActionClass()
+    {
+        return actionClass;
+    }
+
+    public void setActionClass(Class<? extends Action> actionClass)
+    {
+        this.actionClass = actionClass;
+    }
+
+    protected Action createNewAction() throws Exception {
+        return actionClass.newInstance();
+    }
+
+
+    public static ServiceRegistration export(BundleContext context, Class<? extends Action> actionClass)
+    {
+        Command cmd = actionClass.getAnnotation(Command.class);
+        if (cmd == null)
+        {
+            throw new IllegalArgumentException("Action class is not annotated with @Command");
+        }
+        Hashtable props = new Hashtable();
+        props.put("osgi.command.scope", cmd.scope());
+        props.put("osgi.command.function", cmd.name());
+        SimpleCommand command = new SimpleCommand(actionClass);
+        return context.registerService(Function.class.getName(), command, props);
+    }
+
+}
diff --git a/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/converter/DefaultConverter.java b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/converter/DefaultConverter.java
new file mode 100644
index 0000000..277f22e
--- /dev/null
+++ b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/converter/DefaultConverter.java
@@ -0,0 +1,402 @@
+/**
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package org.apache.felix.gogo.commands.converter;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Dictionary;
+import java.util.Locale;
+import java.util.Properties;
+import java.util.Hashtable;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.SortedMap;
+import java.util.TreeMap;
+import java.util.LinkedHashMap;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.Set;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Queue;
+import java.util.LinkedList;
+import java.util.regex.Pattern;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ConcurrentHashMap;
+import java.math.BigInteger;
+import java.math.BigDecimal;
+import java.io.ByteArrayInputStream;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Array;
+import java.lang.reflect.Type;
+import java.lang.reflect.InvocationTargetException;
+
+import org.apache.felix.gogo.commands.converter.ReifiedType;
+
+public class DefaultConverter
+{
+
+    private Object loader;
+
+    public DefaultConverter(Object loader) {
+        this.loader = loader;
+    }
+
+    public Object convert(Object source, Type target) throws Exception {
+        return convert( source, new GenericType(target));
+    }
+
+    public Object convert(Object fromValue, ReifiedType type) throws Exception {
+        // Discard null values
+        if (fromValue == null) {
+            return null;
+        }
+        // If the object is an instance of the type, just return it
+        if (isAssignable(fromValue, type)) {
+            return fromValue;
+        }
+        Object value = convertWithConverters(fromValue, type);
+        if (value == null) {
+            if (fromValue instanceof Number && Number.class.isAssignableFrom(unwrap(toClass(type)))) {
+                return convertToNumber((Number) fromValue, toClass(type));
+            } else if (fromValue instanceof String) {
+                return convertFromString((String) fromValue, toClass(type), loader);
+            } else if (toClass(type).isArray() && (fromValue instanceof Collection || fromValue.getClass().isArray())) {
+                return convertToArray(fromValue, type);
+            } else if (Map.class.isAssignableFrom(toClass(type)) && (fromValue instanceof Map || fromValue instanceof Dictionary)) {
+                return convertToMap(fromValue, type);
+            } else if (Dictionary.class.isAssignableFrom(toClass(type)) && (fromValue instanceof Map || fromValue instanceof Dictionary)) {
+                return convertToDictionary(fromValue, type);
+            } else if (Collection.class.isAssignableFrom(toClass(type)) && (fromValue instanceof Collection || fromValue.getClass().isArray())) {
+                return convertToCollection(fromValue, type);
+            } else {
+                throw new Exception("Unable to convert value " + fromValue + " to type " + type);
+            }
+        }
+        return value;
+    }
+
+    private Object convertWithConverters(Object source, ReifiedType type) throws Exception {
+        Object value = null;
+//        for (Converter converter : converters) {
+//            if (converter.canConvert(source, type)) {
+//                value = converter.convert(source, type);
+//                if (value != null) {
+//                    return value;
+//                }
+//            }
+//        }
+        return value;
+    }
+
+    public Object convertToNumber(Number value, Class toType) throws Exception {
+        toType = unwrap(toType);
+        if (AtomicInteger.class == toType) {
+            return new AtomicInteger((Integer) convertToNumber(value, Integer.class));
+        } else if (AtomicLong.class == toType) {
+            return new AtomicLong((Long) convertToNumber(value, Long.class));
+        } else if (Integer.class == toType) {
+            return value.intValue();
+        } else if (Short.class == toType) {
+            return value.shortValue();
+        } else if (Long.class == toType) {
+            return value.longValue();
+        } else if (Float.class == toType) {
+            return value.floatValue();
+        } else if (Double.class == toType) {
+            return value.doubleValue();
+        } else if (Byte.class == toType) {
+            return value.byteValue();
+        } else if (BigInteger.class == toType) {
+            return new BigInteger(value.toString());
+        } else if (BigDecimal.class == toType) {
+            return new BigDecimal(value.toString());
+        } else {
+            throw new Exception("Unable to convert number " + value + " to " + toType);
+        }
+    }
+
+    public Object convertFromString(String value, Class toType, Object loader) throws Exception {
+        toType = unwrap(toType);
+        if (ReifiedType.class == toType) {
+            try {
+                return GenericType.parse(value, loader);
+            } catch (ClassNotFoundException e) {
+                throw new Exception("Unable to convert", e);
+            }
+        } else if (Class.class == toType) {
+            try {
+                return GenericType.parse(value, loader).getRawClass();
+            } catch (ClassNotFoundException e) {
+                throw new Exception("Unable to convert", e);
+            }
+        } else if (Locale.class == toType) {
+            String[] tokens = value.split("_");
+            if (tokens.length == 1) {
+                return new Locale(tokens[0]);
+            } else if (tokens.length == 2) {
+                return new Locale(tokens[0], tokens[1]);
+            } else if (tokens.length == 3) {
+                return new Locale(tokens[0], tokens[1], tokens[2]);
+            } else {
+                throw new Exception("Invalid locale string:" + value);
+            }
+        } else if (Pattern.class == toType) {
+            return Pattern.compile(value);
+        } else if (Properties.class == toType) {
+            Properties props = new Properties();
+            ByteArrayInputStream in = new ByteArrayInputStream(value.getBytes("UTF8"));
+            props.load(in);
+            return props;
+        } else if (Boolean.class == toType) {
+            if ("yes".equalsIgnoreCase(value) || "true".equalsIgnoreCase(value) || "on".equalsIgnoreCase(value)) {
+                return Boolean.TRUE;
+            } else if ("no".equalsIgnoreCase(value) || "false".equalsIgnoreCase(value) || "off".equalsIgnoreCase(value)) {
+                return Boolean.FALSE;
+            } else {
+                throw new RuntimeException("Invalid boolean value: " + value);
+            }
+        } else if (Integer.class == toType) {
+            return Integer.valueOf(value);
+        } else if (Short.class == toType) {
+            return Short.valueOf(value);
+        } else if (Long.class == toType) {
+            return Long.valueOf(value);
+        } else if (Float.class == toType) {
+            return Float.valueOf(value);
+        } else if (Double.class == toType) {
+            return Double.valueOf(value);
+        } else if (Character.class == toType) {
+            if (value.length() == 6 && value.startsWith("\\u")) {
+                int code = Integer.parseInt(value.substring(2), 16);
+                return (char)code;
+            } else if (value.length() == 1) {
+                return value.charAt(0);
+            } else {
+                throw new Exception("Invalid value for character type: " + value);
+            }
+        } else if (Byte.class == toType) {
+            return Byte.valueOf(value);
+        } else if (Enum.class.isAssignableFrom(toType)) {
+            return Enum.valueOf((Class<Enum>) toType, value);
+        } else {
+            return createObject(value, toType);
+        }
+    }
+
+    private static Object createObject(String value, Class type) throws Exception {
+        if (type.isInterface() || Modifier.isAbstract(type.getModifiers())) {
+            throw new Exception("Unable to convert value " + value + " to type " + type + ". Type " + type + " is an interface or an abstract class");
+        }
+        Constructor constructor = null;
+        try {
+            constructor = type.getConstructor(String.class);
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Unable to convert to " + type);
+        }
+        try {
+            return constructor.newInstance(value);
+        } catch (Exception e) {
+            throw new Exception("Unable to convert ", getRealCause(e));
+        }
+    }
+
+    private static Throwable getRealCause(Throwable t) {
+        if (t instanceof InvocationTargetException && t.getCause() != null) {
+            return t.getCause();
+        }
+        return t;
+    }
+
+    private Object convertToCollection(Object obj, ReifiedType type) throws Exception {
+        ReifiedType valueType = type.getActualTypeArgument(0);
+        Collection newCol = (Collection) getCollection(toClass(type)).newInstance();
+        if (obj.getClass().isArray()) {
+            for (int i = 0; i < Array.getLength(obj); i++) {
+                try {
+                    newCol.add(convert(Array.get(obj, i), valueType));
+                } catch (Exception t) {
+                    throw new Exception("Unable to convert from " + obj + " to " + type + "(error converting array element)", t);
+                }
+            }
+        } else {
+            for (Object item : (Collection) obj) {
+                try {
+                    newCol.add(convert(item, valueType));
+                } catch (Exception t) {
+                    throw new Exception("Unable to convert from " + obj + " to " + type + "(error converting collection entry)", t);
+                }
+            }
+        }
+        return newCol;
+    }
+
+    private Object convertToDictionary(Object obj, ReifiedType type) throws Exception {
+        ReifiedType keyType = type.getActualTypeArgument(0);
+        ReifiedType valueType = type.getActualTypeArgument(1);
+        Dictionary newDic = new Hashtable();
+        if (obj instanceof Dictionary) {
+            Dictionary dic = (Dictionary) obj;
+            for (Enumeration keyEnum = dic.keys(); keyEnum.hasMoreElements();) {
+                Object key = keyEnum.nextElement();
+                try {
+                    newDic.put(convert(key, keyType), convert(dic.get(key), valueType));
+                } catch (Exception t) {
+                    throw new Exception("Unable to convert from " + obj + " to " + type + "(error converting map entry)", t);
+                }
+            }
+        } else {
+            for (Map.Entry e : ((Map<Object,Object>) obj).entrySet()) {
+                try {
+                    newDic.put(convert(e.getKey(), keyType), convert(e.getValue(), valueType));
+                } catch (Exception t) {
+                    throw new Exception("Unable to convert from " + obj + " to " + type + "(error converting map entry)", t);
+                }
+            }
+        }
+        return newDic;
+    }
+
+    private Object convertToMap(Object obj, ReifiedType type) throws Exception {
+        ReifiedType keyType = type.getActualTypeArgument(0);
+        ReifiedType valueType = type.getActualTypeArgument(1);
+        Map newMap = (Map) getMap(toClass(type)).newInstance();
+        if (obj instanceof Dictionary) {
+            Dictionary dic = (Dictionary) obj;
+            for (Enumeration keyEnum = dic.keys(); keyEnum.hasMoreElements();) {
+                Object key = keyEnum.nextElement();
+                try {
+                    newMap.put(convert(key, keyType), convert(dic.get(key), valueType));
+                } catch (Exception t) {
+                    throw new Exception("Unable to convert from " + obj + " to " + type + "(error converting map entry)", t);
+                }
+            }
+        } else {
+            for (Map.Entry e : ((Map<Object,Object>) obj).entrySet()) {
+                try {
+                    newMap.put(convert(e.getKey(), keyType), convert(e.getValue(), valueType));
+                } catch (Exception t) {
+                    throw new Exception("Unable to convert from " + obj + " to " + type + "(error converting map entry)", t);
+                }
+            }
+        }
+        return newMap;
+    }
+
+    private Object convertToArray(Object obj, ReifiedType type) throws Exception {
+        if (obj instanceof Collection) {
+            obj = ((Collection) obj).toArray();
+        }
+        if (!obj.getClass().isArray()) {
+            throw new Exception("Unable to convert from " + obj + " to " + type);
+        }
+        ReifiedType componentType;
+        if (type.size() > 0) {
+            componentType = type.getActualTypeArgument(0);
+        } else {
+            componentType = new GenericType(type.getRawClass().getComponentType());
+        }
+        Object array = Array.newInstance(toClass(componentType), Array.getLength(obj));
+        for (int i = 0; i < Array.getLength(obj); i++) {
+            try {
+                Array.set(array, i, convert(Array.get(obj, i), componentType));
+            } catch (Exception t) {
+                throw new Exception("Unable to convert from " + obj + " to " + type + "(error converting array element)", t);
+            }
+        }
+        return array;
+    }
+
+    public static boolean isAssignable(Object source, ReifiedType target) {
+        return source == null
+                || (target.size() == 0
+                    && unwrap(target.getRawClass()).isAssignableFrom(unwrap(source.getClass())));
+    }
+
+    private static Class unwrap(Class c) {
+        Class u = primitives.get(c);
+        return u != null ? u : c;
+    }
+
+    private static Class getMap(Class type) {
+        if (hasDefaultConstructor(type)) {
+            return type;
+        } else if (SortedMap.class.isAssignableFrom(type)) {
+            return TreeMap.class;
+        } else if (ConcurrentMap.class.isAssignableFrom(type)) {
+            return ConcurrentHashMap.class;
+        } else {
+            return LinkedHashMap.class;
+        }
+    }
+
+    private static Class getCollection(Class type) {
+        if (hasDefaultConstructor(type)) {
+            return type;
+        } else if (SortedSet.class.isAssignableFrom(type)) {
+            return TreeSet.class;
+        } else if (Set.class.isAssignableFrom(type)) {
+            return LinkedHashSet.class;
+        } else if (List.class.isAssignableFrom(type)) {
+            return ArrayList.class;
+        } else if (Queue.class.isAssignableFrom(type)) {
+            return LinkedList.class;
+        } else {
+            return ArrayList.class;
+        }
+    }
+
+    private static boolean hasDefaultConstructor(Class type) {
+        if (!Modifier.isPublic(type.getModifiers())) {
+            return false;
+        }
+        if (Modifier.isAbstract(type.getModifiers())) {
+            return false;
+        }
+        Constructor[] constructors = type.getConstructors();
+        for (Constructor constructor : constructors) {
+            if (Modifier.isPublic(constructor.getModifiers()) &&
+                    constructor.getParameterTypes().length == 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static final Map<Class, Class> primitives;
+    static {
+        primitives = new HashMap<Class, Class>();
+        primitives.put(byte.class, Byte.class);
+        primitives.put(short.class, Short.class);
+        primitives.put(char.class, Character.class);
+        primitives.put(int.class, Integer.class);
+        primitives.put(long.class, Long.class);
+        primitives.put(float.class, Float.class);
+        primitives.put(double.class, Double.class);
+        primitives.put(boolean.class, Boolean.class);
+    }
+
+    private Class toClass(ReifiedType type) {
+        return type.getRawClass();
+    }
+
+}
diff --git a/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/converter/GenericType.java b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/converter/GenericType.java
new file mode 100644
index 0000000..bb9d192
--- /dev/null
+++ b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/converter/GenericType.java
@@ -0,0 +1,195 @@
+/**
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package org.apache.felix.gogo.commands.converter;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.osgi.framework.Bundle;
+import org.apache.felix.gogo.commands.converter.ReifiedType;
+
+public class GenericType extends ReifiedType {
+
+	private static final GenericType[] EMPTY = new GenericType[0];
+
+    private static final Map<String, Class> primitiveClasses = new HashMap<String, Class>();
+
+    static {
+        primitiveClasses.put("int", int.class);
+        primitiveClasses.put("short", short.class);
+        primitiveClasses.put("long", long.class);
+        primitiveClasses.put("byte", byte.class);
+        primitiveClasses.put("char", char.class);
+        primitiveClasses.put("float", float.class);
+        primitiveClasses.put("double", double.class);
+        primitiveClasses.put("boolean", boolean.class);
+    }
+
+    private GenericType[] parameters;
+
+	public GenericType(Type type) {
+		this(getConcreteClass(type), parametersOf(type));
+	}
+
+    public GenericType(Class clazz, GenericType... parameters) {
+        super(clazz);
+        this.parameters = parameters;
+    }
+
+    public static GenericType parse(String type, Object loader) throws ClassNotFoundException, IllegalArgumentException {
+        type = type.trim();
+        // Check if this is an array
+        if (type.endsWith("[]")) {
+            GenericType t = parse(type.substring(0, type.length() - 2), loader);
+            return new GenericType(Array.newInstance(t.getRawClass(), 0).getClass(), t);
+        }
+        // Check if this is a generic
+        int genericIndex = type.indexOf('<');
+        if (genericIndex > 0) {
+            if (!type.endsWith(">")) {
+                throw new IllegalArgumentException("Can not load type: " + type);
+            }
+            GenericType base = parse(type.substring(0, genericIndex), loader);
+            String[] params = type.substring(genericIndex + 1, type.length() - 1).split(",");
+            GenericType[] types = new GenericType[params.length];
+            for (int i = 0; i < params.length; i++) {
+                types[i] = parse(params[i], loader);
+            }
+            return new GenericType(base.getRawClass(), types);
+        }
+        // Primitive
+        if (primitiveClasses.containsKey(type)) {
+            return new GenericType(primitiveClasses.get(type));
+        }
+        // Class
+        if (loader instanceof ClassLoader) {
+            return new GenericType(((ClassLoader) loader).loadClass(type));
+        } else if (loader instanceof Bundle) {
+            return new GenericType(((Bundle) loader).loadClass(type));
+        } else {
+            throw new IllegalArgumentException("Unsupported loader: " + loader);
+        }
+    }
+
+    @Override
+    public ReifiedType getActualTypeArgument(int i) {
+        if (parameters.length == 0) {
+            return super.getActualTypeArgument(i);
+        }
+        return parameters[i];
+    }
+
+    @Override
+    public int size() {
+        return parameters.length;
+    }
+
+    @Override
+    public String toString() {
+        Class cl = getRawClass();
+        if (cl.isArray()) {
+            if (parameters.length > 0) {
+                return parameters[0].toString() + "[]";
+            } else {
+                return cl.getComponentType().getName() + "[]";
+            }
+        }
+        if (parameters.length > 0) {
+            StringBuilder sb = new StringBuilder();
+            sb.append(cl.getName());
+            sb.append("<");
+            for (int i = 0; i < parameters.length; i++) {
+                if (i > 0) {
+                    sb.append(",");
+                }
+                sb.append(parameters[i].toString());
+            }
+            sb.append(">");
+            return sb.toString();
+        }
+        return cl.getName();
+    }
+
+    static GenericType[] parametersOf(Type type ) {
+		if ( type instanceof Class ) {
+		    Class clazz = (Class) type;
+		    if (clazz.isArray()) {
+                GenericType t = new GenericType(clazz.getComponentType());
+                if (t.size() > 0) {
+		            return new GenericType[] { t };
+                } else {
+                    return EMPTY;
+                }
+		    } else {
+		        return EMPTY;
+		    }
+		}
+        if ( type instanceof ParameterizedType ) {
+            ParameterizedType pt = (ParameterizedType) type;
+            Type [] parameters = pt.getActualTypeArguments();
+            GenericType[] gts = new GenericType[parameters.length];
+            for ( int i =0; i<gts.length; i++) {
+                gts[i] = new GenericType(parameters[i]);
+            }
+            return gts;
+        }
+        if ( type instanceof GenericArrayType ) {
+            return new GenericType[] { new GenericType(((GenericArrayType) type).getGenericComponentType()) };
+        }
+        throw new IllegalStateException();
+	}
+
+	static Class<?> getConcreteClass(Type type) {
+		Type ntype = collapse(type);
+		if ( ntype instanceof Class )
+			return (Class<?>) ntype;
+
+		if ( ntype instanceof ParameterizedType )
+			return getConcreteClass(collapse(((ParameterizedType)ntype).getRawType()));
+
+		throw new RuntimeException("Unknown type " + type );
+	}
+
+	static Type collapse(Type target) {
+		if (target instanceof Class || target instanceof ParameterizedType ) {
+			return target;
+		} else if (target instanceof TypeVariable) {
+			return collapse(((TypeVariable<?>) target).getBounds()[0]);
+		} else if (target instanceof GenericArrayType) {
+			Type t = collapse(((GenericArrayType) target)
+					.getGenericComponentType());
+			while ( t instanceof ParameterizedType )
+				t = collapse(((ParameterizedType)t).getRawType());
+			return Array.newInstance((Class<?>)t, 0).getClass();
+		} else if (target instanceof WildcardType) {
+			WildcardType wct = (WildcardType) target;
+			if (wct.getLowerBounds().length == 0)
+				return collapse(wct.getUpperBounds()[0]);
+			else
+				return collapse(wct.getLowerBounds()[0]);
+		}
+		throw new RuntimeException("Huh? " + target);
+	}
+
+}
diff --git a/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/converter/ReifiedType.java b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/converter/ReifiedType.java
new file mode 100644
index 0000000..239616e
--- /dev/null
+++ b/gogo/gogo.commands/src/main/java/org/apache/felix/gogo/commands/converter/ReifiedType.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) OSGi Alliance (2008, 2009). All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.felix.gogo.commands.converter;
+
+/**
+ * Provides access to a concrete type and its optional generic type arguments.
+ *
+ * Java 5 and later support generic types. These types consist of a raw class
+ * with type arguments. This class models such a <code>Type</code> class but
+ * ensures that the type is <em>reified</em>. Reification means that the Type
+ * graph associated with a Java 5 <code>Type</code> instance is traversed
+ * until the type becomes a concrete class. In Java 1.4 a class has no
+ * arguments. This concrete class implements the Reified Type for Java 1.4.
+ *
+ * In Java 1.4, this class works with non-generic types. In that cases, a
+ * Reified Type provides access to the class and has zero type arguments, though
+ * a subclass that provide type arguments should be respected. Blueprint
+ * extender implementations can subclass this class and provide access to the
+ * generics type graph if used in a conversion. Such a subclass must
+ * <em>reify<em> the different Java 5 <code>Type</code> instances into the
+ * reified form. That is, a form where the raw Class is available with its optional type arguments as Reified Types.
+ *
+ * @Immutable
+ */
+public class ReifiedType {
+	final static ReifiedType ALL = new ReifiedType(Object.class);
+
+	private final Class clazz;
+
+	/**
+	 * Create a Reified Type for a raw Java class without any generic arguments.
+	 * Subclasses can provide the optional generic argument information. Without
+	 * subclassing, this instance has no type arguments.
+	 *
+	 * @param clazz
+	 *            The raw class of the Reified Type.
+	 */
+	public ReifiedType(Class clazz) {
+		this.clazz = clazz;
+	}
+
+	/**
+	 * Access to the raw class.
+	 *
+	 * The raw class represents the concrete class that is associated with a
+	 * type declaration. This class could have been deduced from the generics
+	 * type graph of the declaration. For example, in the following example:
+	 *
+	 * <pre>
+	 * Map&lt;String, Object&gt; map;
+	 * </pre>
+	 *
+	 * The raw class is the Map class.
+	 *
+	 * @return the collapsed raw class that represents this type.
+	 */
+	public Class getRawClass() {
+		return clazz;
+	}
+
+	/**
+	 * Access to a type argument.
+	 *
+	 * The type argument refers to a argument in a generic type declaration
+	 * given by index <code>i</code>. This method returns a Reified Type that
+	 * has Object as class when no generic type information is available. Any
+	 * object is assignable to Object and therefore no conversion is then
+	 * necessary, this is compatible with older Javas than 5. For this reason,
+	 * the implementation in this class always returns the
+	 * <code>Object<code> class, regardless of the given index.
+	 *
+	 * This method should be overridden by a subclass that provides access to
+	 * the generic information.
+	 *
+	 * For example, in the following example:
+	 *
+	 * <pre>
+	 * Map&lt;String, Object&gt; map;
+	 * </pre>
+	 *
+	 * The type argument 0 is <code>String</code>, and type argument 1 is
+	 * <code>Object</code>.
+	 *
+	 * @param i
+	 *            The index of the type argument
+	 * @return <code>ReifiedType(Object.class)<code>, subclasses must override this and return the generic argument at index <code>i</code>
+	 */
+	public ReifiedType getActualTypeArgument(int i) {
+		return ALL;
+	}
+
+	/**
+	 * Return the number of type arguments.
+	 *
+	 * This method should be overridden by a subclass to support Java 5 types.
+	 *
+	 * @return 0, subclasses must override this and return the number of generic
+	 *         arguments
+	 */
+	public int size() {
+		return 0;
+	}
+}
diff --git a/gogo/gogo.commands/src/test/java/org/apache/felix/gogo/commands/TestCommands.java b/gogo/gogo.commands/src/test/java/org/apache/felix/gogo/commands/TestCommands.java
new file mode 100644
index 0000000..1b3fc22
--- /dev/null
+++ b/gogo/gogo.commands/src/test/java/org/apache/felix/gogo/commands/TestCommands.java
@@ -0,0 +1,87 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.felix.gogo.commands;
+
+import java.util.List;
+import java.util.Collections;
+import java.util.Arrays;
+
+import junit.framework.TestCase;
+import org.osgi.service.command.CommandSession;
+import org.apache.felix.gogo.runtime.shell.Context;
+import org.apache.felix.gogo.commands.basic.SimpleCommand;
+
+public class TestCommands extends TestCase {
+
+
+    public void testCommand() throws Exception {
+        Context c= new Context();
+        c.addCommand("my-action", new SimpleCommand(MyAction.class));
+
+        // Test help
+        c.execute("my-action --help");
+
+        // Test required argument
+        try
+        {
+            c.execute("my-action");
+            fail("Action should have thrown an exception because of a missing argument");
+        }
+        catch (IllegalArgumentException e)
+        {
+        }
+
+        // Test required argument
+        assertEquals(Arrays.asList(3), c.execute("my-action 3"));
+
+        // Test required argument
+        assertEquals(Arrays.asList(3), c.execute("my-action 3"));
+
+        // Test required argument
+        assertEquals(Arrays.asList(3, 5), c.execute("my-action 3 5"));
+
+        // Test option
+        assertEquals(Arrays.asList(4), c.execute("my-action -i 3"));
+
+        // Test option alias
+        assertEquals(Arrays.asList(4), c.execute("my-action --increment 3"));
+    }
+
+    @Command(scope = "test", name = "my-action", description = "My Action")
+    public static class MyAction implements Action
+    {
+
+        @Option(name = "-i", aliases = { "--increment" }, description = "First option")
+        private boolean increment;
+
+        @Argument(name = "ids", description = "Bundle ids", required = true, multiValued = true)
+        private List<Integer> ids;
+
+        public Object execute(CommandSession session) throws Exception {
+            if (increment)
+            {
+                for (int i = 0; i < ids.size(); i++)
+                {
+                    ids.set(i, ids.get(i) + 1);
+                }
+            }
+            return ids;
+        }
+    }
+}
diff --git a/gogo/gogo.console/src/main/java/org/apache/felix/gogo/console/stdio/StdioConsole.java b/gogo/gogo.console/src/main/java/org/apache/felix/gogo/console/stdio/StdioConsole.java
index 15c1ed1..e83c1b4 100644
--- a/gogo/gogo.console/src/main/java/org/apache/felix/gogo/console/stdio/StdioConsole.java
+++ b/gogo/gogo.console/src/main/java/org/apache/felix/gogo/console/stdio/StdioConsole.java
@@ -19,7 +19,6 @@
 package org.apache.felix.gogo.console.stdio;
 
 import org.osgi.service.command.CommandProcessor;
-import org.osgi.service.component.ComponentContext;
 
 public class StdioConsole extends Thread
 {
diff --git a/gogo/gogo.runtime/pom.xml b/gogo/gogo.runtime/pom.xml
index 22c6dfb..b2f0362 100644
--- a/gogo/gogo.runtime/pom.xml
+++ b/gogo/gogo.runtime/pom.xml
@@ -59,7 +59,6 @@
                             org.osgi.service.threadio; version=1.0.0
                         </Export-Package>
                         <Import-Package>
-                            org.osgi.service.component*; resolution:=optional,
                             org.osgi.service.log*; resolution:=optional,
                             org.osgi.service.packageadmin*; resolution:=optional,
                             org.osgi.service.startlevel*; resolution:=optional,
@@ -69,6 +68,7 @@
                         <Bundle-SymbolicName>${pom.artifactId}</Bundle-SymbolicName>
                         <Bundle-Vendor>The Apache Software Foundation</Bundle-Vendor>
                         <Bundle-Activator>org.apache.felix.gogo.runtime.Activator</Bundle-Activator>
+                        <_versionpolicy>[$(version;==;$(@)),$(version;+;$(@)))</_versionpolicy>
                     </instructions>
                 </configuration>
             </plugin>
diff --git a/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/equinox/Equinox.java b/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/equinox/Equinox.java
deleted file mode 100644
index 8187496..0000000
--- a/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/equinox/Equinox.java
+++ /dev/null
@@ -1,476 +0,0 @@
-package org.apache.felix.gogo.runtime.equinox;
-
-import org.osgi.framework.Bundle;
-import org.osgi.framework.BundleContext;
-import org.osgi.framework.BundleException;
-import org.osgi.framework.ServiceReference;
-import org.osgi.service.command.CommandProcessor;
-import org.osgi.service.command.CommandSession;
-import org.osgi.service.command.Converter;
-import org.osgi.service.component.ComponentContext;
-import org.osgi.service.log.LogEntry;
-import org.osgi.service.log.LogReaderService;
-import org.osgi.service.log.LogService;
-import org.osgi.service.packageadmin.ExportedPackage;
-import org.osgi.service.packageadmin.PackageAdmin;
-import org.osgi.service.startlevel.StartLevel;
-
-import java.io.IOException;
-import java.net.URL;
-import java.util.*;
-
-public class Equinox implements Converter
-{
-    BundleContext context;
-    PackageAdmin pka;
-    LogReaderService lrs;
-    StartLevel sls;
-    final static String[] functions = {"active", "bundles", "close", "diag", "exec", "exit", "fork", "gc", "getprop", "headers", "init", "install", "launch", "log", "packages", "packages", "refresh", "services", "setbsl", "setfwsl", "setibsl", "setprop", "shutdown", "sl", "ss", "start", "status", "stop", "uninstall", "update"};
-
-    protected void activate(ComponentContext context)
-    {
-        this.context = context.getBundleContext();
-        Dictionary<String, Object> dict = new Hashtable<String, Object>();
-        dict.put(CommandProcessor.COMMAND_SCOPE, "eqx");
-        dict.put(CommandProcessor.COMMAND_FUNCTION, functions);
-        this.context.registerService(Converter.class.getName(), this, dict);
-    }
-
-    BundleContext getContext()
-    {
-        return context;
-    }
-
-    public void setPka(PackageAdmin pka)
-    {
-        this.pka = pka;
-    }
-
-    public void setLrs(LogReaderService lrs)
-    {
-        this.lrs = lrs;
-    }
-
-    public void setSls(StartLevel sls)
-    {
-        this.sls = sls;
-    }
-
-    /**
-     * - Displays unsatisfied constraints for the specified bundle(s).
-     */
-    public void diag()
-    {
-    }
-
-    /*
-     * active - Displays a list of all bundles currently in the ACTIVE state.
-     */
-    public List<Bundle> active()
-    {
-        List<Bundle> result = new ArrayList<Bundle>();
-        Bundle[] bundles = getContext().getBundles();
-        for (Bundle b : bundles)
-        {
-            if (b.getState() == Bundle.ACTIVE)
-            {
-                result.add(b);
-            }
-        }
-        return result;
-    }
-
-    /*
-     * getprop { name } - Displays the system properties with the given name, or
-     * all of them.
-     */
-
-    public Object getprop(CharSequence name)
-    {
-        if (name == null)
-        {
-            return System.getProperties();
-        }
-        else
-        {
-            return System.getProperty(name.toString());
-        }
-    }
-
-    /**
-     * launch - start the OSGi Framework
-     */
-
-    public void launch()
-    {
-        throw new IllegalStateException("Already running");
-    }
-
-    /**
-     * shutdown - shutdown the OSGi Framework
-     */
-    public void shutdown() throws BundleException
-    {
-        getContext().getBundle().stop();
-    }
-
-    /**
-     * close - shutdown and exit
-     */
-    public void close(CommandSession session)
-    {
-        session.close();
-    }
-
-    /**
-     * exit - exit immediately (System.exit)
-     */
-
-    public void exit(int exitValue)
-    {
-        exit(exitValue);
-    }
-
-    /**
-     * gc - perform a garbage collection
-     */
-    public long gc()
-    {
-        Runtime.getRuntime().gc();
-        return Runtime.getRuntime().freeMemory();
-    }
-
-    /**
-     * init - uninstall all bundles
-     */
-
-    public void init() throws Exception
-    {
-        Bundle bundles[] = getContext().getBundles();
-        for (Bundle b : bundles)
-        {
-            if (b.getBundleId() != 0)
-            {
-                b.uninstall();
-            }
-        }
-    }
-
-    /**
-     * setprop <key>=<value> - set the OSGi property
-     */
-    public void setprop(CommandSession session, String key, String value)
-    {
-        session.put(key, value);
-    }
-
-    /**
-     * install - install and optionally start bundle from the given URL
-     *
-     * @throws BundleException
-     */
-
-    public Bundle install(URL url) throws BundleException
-    {
-        return getContext().installBundle(url.toExternalForm());
-    }
-
-    /**
-     * uninstall - uninstall the specified bundle(s)
-     *
-     * @throws BundleException
-     */
-    public void uninstall(Bundle[] bundles) throws BundleException
-    {
-        for (Bundle b : bundles)
-        {
-            b.uninstall();
-        }
-    }
-
-    /**
-     * start - start the specified bundle(s)
-     */
-    public void start(Bundle[] bundles) throws BundleException
-    {
-        for (Bundle b : bundles)
-        {
-            b.start();
-        }
-    }
-
-    /**
-     * stop - stop the specified bundle(s)
-     */
-    public void stop(Bundle[] bundles) throws BundleException
-    {
-        for (Bundle b : bundles)
-        {
-            b.stop();
-        }
-    }
-
-    /**
-     * refresh - refresh the packages of the specified bundles
-     */
-    public void refresh(Bundle[] bundles) throws Exception
-    {
-        if (pka != null)
-        {
-            pka.refreshPackages(bundles);
-        }
-        else
-        {
-            throw new RuntimeException("No PackageAdmin service registered");
-        }
-    }
-
-    /**
-     * update - update the specified bundle(s)
-     */
-    public void update(Bundle[] bundles) throws BundleException
-    {
-        for (Bundle b : bundles)
-        {
-            b.update();
-        }
-    }
-
-    /**
-     * status - display installed bundles and registered services
-     */
-    public List<Object> status() throws Exception
-    {
-        List<Object> status = new ArrayList<Object>();
-        status.addAll(Arrays.asList(getContext().getBundles()));
-        status.addAll(Arrays.asList(getContext().getServiceReferences(null, null)));
-        return status;
-    }
-
-    /**
-     * ss - display installed bundles (short status)
-     */
-    public Bundle[] ss()
-    {
-        return getContext().getBundles();
-    }
-
-    /**
-     * services {filter} - display registered service details
-     */
-    public ServiceReference[] services(String filter) throws Exception
-    {
-        return getContext().getServiceReferences(null, filter);
-    }
-
-    /**
-     * packages {<pkgname>|<id>|<location>} - display imported/exported
-     * package details
-     */
-    public ExportedPackage[] packages(Bundle bundle) throws Exception
-    {
-        if (pka != null)
-        {
-            return pka.getExportedPackages(bundle);
-        }
-        else
-        {
-            throw new RuntimeException("No PackageAdmin service registered");
-        }
-    }
-
-    public ExportedPackage[] packages(String packageName) throws Exception
-    {
-        if (pka != null)
-        {
-            return pka.getExportedPackages(packageName);
-        }
-        return null;
-    }
-
-    /**
-     * bundles - display details for all installed bundles
-     */
-    public Bundle[] bundles()
-    {
-        return ss();
-    }
-
-    /**
-     * bundle (<id>|<location>) - display details for the specified bundle(s)
-     */
-
-    /**
-     * headers (<id>|<location>) - print bundle headers
-     */
-
-    @SuppressWarnings("unchecked")
-    public Dictionary headers(Bundle b, String locale)
-    {
-        return b.getHeaders(locale);
-    }
-
-    /**
-     * log (<id>|<location>) - display log entries
-     */
-
-    @SuppressWarnings("unchecked")
-    public Collection<LogEntry> log(Bundle bundle) throws Exception
-    {
-        if (lrs != null)
-        {
-            return Collections.list((Enumeration<LogEntry>) lrs.getLog());
-        }
-        else
-        {
-            throw new RuntimeException("LogReader not available");
-        }
-    }
-
-    /**
-     * exec <command> - execute a command in a separate process and wait
-     *
-     * @throws IOException
-     */
-
-    public int exec(Object[] args, boolean fork) throws IOException
-    {
-        StringBuffer sb = new StringBuffer();
-        String del = "";
-        for (Object arg : args)
-        {
-            sb.append(del);
-            sb.append(arg);
-            del = " ";
-        }
-        Process p = Runtime.getRuntime().exec(sb.toString());
-        if (fork)
-        {
-            int c;
-            while ((c = p.getInputStream().read()) > 0)
-            {
-                System.out.print(c);
-            }
-        }
-        return p.exitValue();
-    }
-
-    /**
-     * fork <command> - execute a command in a separate process
-     */
-
-    public void fork(Object args[]) throws Exception
-    {
-        exec(args, true);
-    }
-
-    /**
-     * sl {(<id>|<location>)} - display the start level for the specified
-     * bundle, or for the framework if no bundle specified
-     */
-    public int sl(Bundle b) throws Exception
-    {
-        if (sls == null)
-        {
-            throw new RuntimeException("No StartLevel service registered");
-        }
-        if (b == null)
-        {
-            return sls.getStartLevel();
-        }
-        else
-        {
-            return sls.getBundleStartLevel(b);
-        }
-    }
-
-    /**
-     * setfwsl <start level> - set the framework start level
-     */
-    public int setfwsl(int n) throws Exception
-    {
-        if (sls == null)
-        {
-            throw new RuntimeException("No StartLevel service registered");
-        }
-        int old = sls.getStartLevel();
-        sls.setStartLevel(n);
-        return old;
-    }
-
-    /**
-     * setbsl <start level> (<id>|<location>) - set the start level for the
-     * bundle(s)
-     */
-    public int setbsl(Bundle b, int n) throws Exception
-    {
-        if (sls == null)
-        {
-            throw new RuntimeException("No StartLevel service registered");
-        }
-        int old = sls.getBundleStartLevel(b);
-        sls.setBundleStartLevel(b, n);
-        return old;
-    }
-
-    /**
-     * setibsl <start level> - set the initial bundle start level
-     */
-    public int setibsl(int n) throws Exception
-    {
-        if (sls == null)
-        {
-            throw new RuntimeException("No StartLevel service registered");
-        }
-        int old = sls.getInitialBundleStartLevel();
-        sls.setInitialBundleStartLevel(n);
-        return old;
-    }
-
-    public Object convert(Class<?> desiredType, Object in) throws Exception
-    {
-        return null;
-    }
-
-    String getLevel(int index)
-    {
-        switch (index)
-        {
-            case LogService.LOG_DEBUG:
-                return "DEBUG";
-            case LogService.LOG_INFO:
-                return "INFO ";
-            case LogService.LOG_WARNING:
-                return "WARNI";
-            case LogService.LOG_ERROR:
-                return "ERROR";
-            default:
-                return "<" + index + ">";
-        }
-    }
-
-    public CharSequence format(Object target, int level, Converter escape)
-    {
-        if (target instanceof LogEntry)
-        {
-            LogEntry entry = (LogEntry) target;
-            switch (level)
-            {
-                case LINE:
-                    Formatter f = new Formatter();
-                    f.format("%tT %04d %s %s", entry.getTime(), entry.getBundle().getBundleId(), getLevel(entry.getLevel()) + "", entry.getMessage() + "");
-                    return f.toString();
-
-                case PART:
-                    Formatter f2 = new Formatter();
-                    f2.format("%tT %s", entry.getTime(), entry.getMessage());
-                    return f2.toString();
-            }
-        }
-        return null;
-    }
-    /**
-     * profilelog - Display & flush the profile log messages
-     */
-
-}
diff --git a/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/osgi/OSGiShell.java b/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/osgi/OSGiShell.java
index 75bdcf6..e968740 100644
--- a/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/osgi/OSGiShell.java
+++ b/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/osgi/OSGiShell.java
@@ -26,7 +26,6 @@
 import org.osgi.framework.InvalidSyntaxException;
 import org.osgi.framework.ServiceReference;
 import org.osgi.service.command.Converter;
-import org.osgi.service.component.ComponentContext;
 import org.osgi.service.packageadmin.PackageAdmin;
 import org.osgi.service.threadio.ThreadIO;
 
@@ -35,16 +34,6 @@
     Bundle bundle;
     OSGiCommands commands;
 
-    protected void activate(ComponentContext context) throws Exception
-    {
-        this.bundle = context.getBundleContext().getBundle();
-        if (threadIO == null)
-        {
-            threadIO = (ThreadIO) context.locateService("x");
-        }
-        start();
-    }
-
     public void start() throws Exception
     {
         commands = new OSGiCommands(bundle);
@@ -84,11 +73,6 @@
         }
     }
 
-    protected void deactivate(ComponentContext context)
-    {
-        System.out.println("Deactivating");
-    }
-
     public Object get(String name)
     {
         if (bundle.getBundleContext() != null)
diff --git a/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/shell/Closure.java b/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/shell/Closure.java
index e479bac..3bc61a5 100644
--- a/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/shell/Closure.java
+++ b/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/shell/Closure.java
@@ -235,7 +235,7 @@
                 {
                     return false;
                 }
-                return seq;
+                return result;
         }
     }
 
diff --git a/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/shell/Parser.java b/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/shell/Parser.java
index 6d6e7cd..44a5153 100644
--- a/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/shell/Parser.java
+++ b/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/shell/Parser.java
@@ -28,7 +28,7 @@
     int current = 0;
     CharSequence text;
     boolean escaped;
-    static final String SPECIAL = "<;|{[\"'$'`(=";
+    static final String SPECIAL = "<;|{[\"'$`(=";
 
     public Parser(CharSequence program)
     {
@@ -71,24 +71,29 @@
 
     char peek()
     {
+        return peek(false);
+    }
+
+    char peek(boolean increment)
+    {
         escaped = false;
         if (eof())
         {
             return 0;
         }
 
-        char c = text.charAt(current);
+        int last = current;
+        char c = text.charAt(current++);
 
         if (c == '\\')
         {
             escaped = true;
-            ++current;
             if (eof())
             {
                 throw new RuntimeException("Eof found after \\"); // derek
             }
 
-            c = text.charAt(current);
+            c = text.charAt(current++);
 
             switch (c)
             {
@@ -113,12 +118,16 @@
                     break;
                 case 'u':
                     c = unicode();
+                    current += 4;
                     break;
                 default:
                     // We just take the next character literally
                     // but have the escaped flag set, important for {},[] etc
             }
         }
+        if (!increment) {
+            current = last;
+        }
         return c;
     }
 
@@ -200,7 +209,6 @@
                 }
                 next();
             }
-
             return text.subSequence(start, current);
         }
         else
@@ -215,59 +223,45 @@
 
         int start = current;
         char c = next();
-        switch (c)
-        {
-            case '{':
-                return text.subSequence(start, find('}', '{'));
-            case '(':
-                return text.subSequence(start, find(')', '('));
-            case '[':
-                return text.subSequence(start, find(']', '['));
-            case '"':
-                return text.subSequence(start + 1, quote('"'));
-            case '\'':
-                return text.subSequence(start + 1, quote('\''));
-            case '<':
-                return text.subSequence(start, find('>', '<'));
-            case '$':
-                value();
-                return text.subSequence(start, current);
-        }
-
-        if (Character.isJavaIdentifierPart(c))
-        {
-            // Some identifier or number
-            while (!eof())
+        if (!escaped) {
+            switch (c)
             {
-                c = peek();
-                if (c != ':' && !Character.isJavaIdentifierPart(c) && c != '.')
-                {
-                    break;
-                }
-                next();
-            }
-        }
-        else
-        {
-            // Operator, repeat while in operator class
-            while (!eof())
-            {
-                c = peek();
-                if (Character.isWhitespace(c) || Character.isJavaIdentifierPart(c))
-                {
-                    break;
-                }
+                case '{':
+                    return text.subSequence(start, find('}', '{'));
+                case '(':
+                    return text.subSequence(start, find(')', '('));
+                case '[':
+                    return text.subSequence(start, find(']', '['));
+                case '"':
+                    return text.subSequence(start + 1, quote('"'));
+                case '\'':
+                    return text.subSequence(start + 1, quote('\''));
+                case '<':
+                    return text.subSequence(start, find('>', '<'));
+                case '$':
+                    value();
+                    return text.subSequence(start, current);
+                case '=':
+                    return text.subSequence(start, current);
             }
         }
 
+        // Some identifier or number
+        while (!eof())
+        {
+            c = peek();
+            if ((!escaped && SPECIAL.indexOf(c) >= 0) || Character.isWhitespace(c))
+            {
+                break;
+            }
+            next();
+        }
         return text.subSequence(start, current);
     }
 
     char next()
     {
-        char c = peek();
-        current++;
-        return c;
+        return peek(true);
     }
 
     char unicode()
diff --git a/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/threadio/ThreadIOImpl.java b/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/threadio/ThreadIOImpl.java
index b9cab7a..2f15984 100644
--- a/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/threadio/ThreadIOImpl.java
+++ b/gogo/gogo.runtime/src/main/java/org/apache/felix/gogo/runtime/threadio/ThreadIOImpl.java
@@ -19,7 +19,6 @@
 // DWB20: ThreadIO should check and reset IO if something (e.g. jetty) overrides
 package org.apache.felix.gogo.runtime.threadio;
 
-import org.osgi.service.component.ComponentContext;
 import org.osgi.service.threadio.ThreadIO;
 
 import java.io.InputStream;
@@ -34,23 +33,6 @@
     ThreadInputStream in = new ThreadInputStream(System.in);
     ThreadLocal<Marker> current = new ThreadLocal<Marker>();
 
-    protected void activate(ComponentContext context)
-    {
-        start();
-    }
-
-    protected void deactivate()
-    {
-        stop();
-    }
-
-    public void stop()
-    {
-        System.setErr(err.dflt);
-        System.setOut(out.dflt);
-        System.setIn(in.dflt);
-    }
-
     public void start()
     {
         if (System.out instanceof ThreadPrintStream)
@@ -62,6 +44,13 @@
         System.setErr(err);
     }
 
+    public void stop()
+    {
+        System.setErr(err.dflt);
+        System.setOut(out.dflt);
+        System.setIn(in.dflt);
+    }
+
     private void checkIO()
     {    // derek
         if (System.in != in)
diff --git a/gogo/gogo.runtime/src/test/java/org/apache/felix/gogo/runtime/shell/TestParser.java b/gogo/gogo.runtime/src/test/java/org/apache/felix/gogo/runtime/shell/TestParser.java
index aea28f1..0aa294c 100644
--- a/gogo/gogo.runtime/src/test/java/org/apache/felix/gogo/runtime/shell/TestParser.java
+++ b/gogo/gogo.runtime/src/test/java/org/apache/felix/gogo/runtime/shell/TestParser.java
@@ -35,6 +35,15 @@
 {
     int beentheredonethat = 0;
 
+    public void testScope() throws Exception
+    {
+        Context c= new Context();
+        c.addCommand("echo", this);
+        c.addCommand("capture", this);
+        assertEquals("$a", c.execute("test:echo \\$a | capture"));
+        assertEquals("file://poo", c.execute("test:echo file://poo|capture"));
+    }
+
     public void testPipe() throws Exception
     {
         Context c = new Context();
@@ -98,6 +107,7 @@
         CharSequence cs = parser.messy();
         assertEquals("a|b;c", cs.toString());
         assertEquals("a|b;c", new Parser(cs).unescape());
+        assertEquals("$a", new Parser("\\$a").unescape());
     }
 
 
diff --git a/gogo/pom.xml b/gogo/pom.xml
index be4ab33..bb875f1 100644
--- a/gogo/pom.xml
+++ b/gogo/pom.xml
@@ -27,6 +27,7 @@
     <modelVersion>4.0.0</modelVersion>
     <packaging>pom</packaging>
     <name>Apache Felix Gogo Shell</name>
+    <description>Apache Felix Gogo Shell</description>
     <groupId>org.apache.felix.gogo</groupId>
     <artifactId>gogo</artifactId>
     <version>1.0.0-SNAPSHOT</version>
@@ -35,6 +36,7 @@
         <module>gogo.runtime</module>
         <module>gogo.launcher</module>
         <module>gogo.console</module>
+        <module>gogo.commands</module>
     </modules>
 
     <dependencyManagement>
diff --git a/gogo/src/main/java/org/osgi/framework/boot/SystemBundle.java b/gogo/src/main/java/org/osgi/framework/boot/SystemBundle.java
deleted file mode 100644
index 25cd373..0000000
--- a/gogo/src/main/java/org/osgi/framework/boot/SystemBundle.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.osgi.framework.boot;
-
-import java.util.Properties;
-
-/**
- * This interface should be implemented by framework implementations when their
- * main object is created. It allows a configurator to set the properties and
- * launch the framework.
- *
- * @author aqute
- */
-public interface SystemBundle
-{
-    /**
-     * The name of a Security Manager class with public empty constructor. A
-     * valid value is also true, this means that the framework should
-     * instantiate its own security manager. If not set, security could be
-     * defined by a parent framework or there is no security. This can be
-     * detected by looking if there is a security manager set
-     */
-    String SECURITY = "org.osgi.framework.security";
-
-    /**
-     * A valid file path in the file system to a directory that exists. The
-     * framework is free to use this directory as it sees fit. This area can not
-     * be shared with anything else. If this property is not set, the framework
-     * should use a file area from the parent bundle. If it is not embedded, it
-     * must use a reasonable platform default.
-     */
-    String STORAGE = "org.osgi.framework.storage";
-
-    /*
-     * A list of paths (separated by path separator) that point to additional
-     * directories to search for platform specific libraries
-     */ String LIBRARIES = "org.osgi.framework.libraries";
-    /*
-     * The command to give a file executable permission. This is necessary in
-     * some environments for running shared libraries.
-     */ String EXECPERMISSION = "org.osgi.framework.command.execpermission";
-
-    /*
-     * Points to a directory with certificates. ###??? Keystore? Certificate
-     * format?
-     */ String ROOT_CERTIFICATES = "org.osgi.framework.root.certificates";
-
-    /*
-     * Set by the configurator but the framework should provide a reasonable
-     * default.
-     */ String WINDOWSYSTEM = "org.osgi.framework.windowsystem";
-
-    /**
-     * Configure this framework with the given properties. These properties can
-     * contain framework specific properties or of the general kind defined in
-     * the specification or in this interface.
-     *
-     * @param properties The properties. This properties can be backed by another
-     *                   properties, it can there not be assumed that it contains all
-     *                   keys. Use it only through the getProperty methods. This parameter may be null.
-     */
-    void init(Properties configuration);
-
-    /**
-     * Wait until the framework is completely finished.
-     * <p/>
-     * This method will return if the framework is stopped and has cleaned up
-     * all the framework resources.
-     *
-     * @param timeout Maximum number of milliseconds to wait until the framework is finished. Specifying a zero will wait indefinitely.
-     */
-
-    void join(long timeout) throws InterruptedException;
-}